#import os
from database import db_session

from flask import flash
from flask import Flask
from flask import redirect
from flask import render_template
from flask import request
from flask import session
from flask import url_for
from flask import jsonify
from flask import Response

from functools import wraps

from werkzeug import secure_filename
from werkzeug.datastructures import Headers

import mimetypes

from managers.desarrollo_mgr import *
from managers.proyectos_mgr import *
from managers.usuarios_mgr import *
from managers.seguridad_mgr import *
from managers.fases_mgr import *
from managers.tipositem_mgr import *
from managers.items_mgr import *
from managers.lineabase_mgr import *
from managers.solicitud_mgr import *
from managers.reportes_mgr import *
from managers.pdfs import create_pdf
from managers.graficador_mgr import *

from models import *

import matplotlib.pyplot as plt
import networkx as nx
import StringIO
#import pydot

app = Flask(__name__)

app.config.from_object('config')
app.secret_key = app.config['APP_SECRET_KEY']

#####Funciones auxiliares

def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        user_id = session.get('id_usuario')
        if not user_id:
            return redirect(url_for('login'))
        return f(*args, **kwargs)
    return decorated_function

def _get_unauthorized_view():
    return redirect(url_for('no_autorizado'))

def roles_required(*roles):
    """Decorador que especifica que un usuario debe tener todos los 
    roles especificados."""
    def wrapper(fn):
        @wraps(fn)
        def decorated_view(*args, **kwargs):
            id_usuario = session['id_usuario']
            nombre_proyecto = None
            nombre_fase = None
            try:
                nombre_proyecto = session['nombre_proyecto']
                nombre_fase = session['nombre_fase']
            except:
                pass
            lista_permisos = buscar_roles(id_usuario, nombre_proyecto, \
            nombre_fase)
            for rol in roles:
                continuar = False
                for permiso in lista_permisos:
                    if rol == permiso:
                        continuar = True
                if(not continuar):
                    return _get_unauthorized_view()
            return fn(*args, **kwargs)
        return decorated_view
    return wrapper

def roles_accepted(*roles):
    """Decorador que especifica que un usuario debe tener al menos uno
    de los roles especificados"""
    def wrapper(fn):
        @wraps(fn)
        def decorated_view(*args, **kwargs):
            id_usuario = session['id_usuario']
            nombre_proyecto = None
            nombre_fase = None
            try:
                nombre_proyecto = session['nombre_proyecto']
                nombre_fase = session['nombre_fase']
            except:
                pass
            lista_permisos = buscar_roles(id_usuario, nombre_proyecto, \
            nombre_fase)
            for rol in roles:
                continuar = False
                for permiso in lista_permisos:
                    if rol == permiso:
                        continuar = True
                if(continuar):
                    return fn(*args, **kwargs)
            return _get_unauthorized_view()
        return decorated_view
    return wrapper

@app.teardown_request
def shutdown_session(exception=None):
    db_session.remove()

def crear_respuesta(archivo, nombre_archivo):
    response = Response()
    response.status_code = 200
    response.data = archivo.getvalue()
    mimetype_tuple = mimetypes.guess_type(nombre_archivo)

    response_headers = Headers({
        'Pragma': "public",  # required,
        'Expires': '0',
        'Cache-Control': 'must-revalidate, post-check=0, pre-check=0',
        'Cache-Control': 'private',  # required for certain browsers,
        'Content-Type': mimetype_tuple[0],
        'Content-Disposition': 'attachment; filename=\"%s\";' % nombre_archivo,
        'Content-Transfer-Encoding': 'binary',
        'Content-Length': len(response.data)
    })

    if not mimetype_tuple[1] is None:
        response.update({
                'Content-Encoding': mimetype_tuple[1]
        })

    response.headers = response_headers

    return response

def crear_respuesta_descarga(archivo, nombre_archivo):
    response = Response()
    response.status_code = 200
    response.data = archivo
    mimetype_tuple = mimetypes.guess_type(nombre_archivo)

    response_headers = Headers({
        'Pragma': "public",  # required,
        'Expires': '0',
        'Cache-Control': 'must-revalidate, post-check=0, pre-check=0',
        'Cache-Control': 'private',  # required for certain browsers,
        'Content-Type': mimetype_tuple[0],
        'Content-Disposition': 'attachment; filename=\"%s\";' % nombre_archivo,
        'Content-Transfer-Encoding': 'binary',
        'Content-Length': len(response.data)
    })

    if not mimetype_tuple[1] is None:
        response.update({
                'Content-Encoding': mimetype_tuple[1]
        })

    response.headers = response_headers

    return response

##########

@app.route('/login', methods=['GET', 'POST'])
def login():
    """El metodo recibe el nombre de usuario y la contrasena. En caso
    de que los parametros sean validos, se accede al sistema. En caso
    contrario, se despliega el mensaje de error correspondiente"""
    error = None
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        validacion = verificar_login(username, password)
        if validacion:
            session['id_usuario'] = username
            return redirect(url_for('menu_principal'))
        else:
            error = 'Login Incorrecto'
    return render_template('login.html', error=error, password='')

@app.route('/logout')
def logout():
    """Cierra la sesion actual, y regresa a la pagina de login"""
    session.pop('id_usuario', None)
    session.clear()
    return redirect(url_for('login'))

@app.route('/')
def index():
    """Redirecciona a la pagina de login"""
    return redirect(url_for('login'))

@app.route('/no_autorizado', methods=['GET', 'POST'])
def no_autorizado():
    """Pagina que se despliega cuando un usuario no posee los permisos 
    necesarios para acceder a cierta caracteristica del sistema"""
    id_usuario = session['id_usuario']
    return render_template('error_permisos.html', id_usuario=id_usuario)

@app.route('/menu_principal')
@login_required
def menu_principal():
    """Despliega el menu principal"""
    error = None
    id_usuario = session['id_usuario']
    return render_template('menu_principal.html', error=error, \
    id_usuario=id_usuario)

@app.route('/administrar_usuarios', methods=['GET', 'POST'])
@login_required
@roles_accepted('Administrador')
def administrar_usuarios():
    """Despliega la lista de usuarios del sistema, ademas de brindar
    acceso a las distintas acciones que se pueden realizar sobre los
    mismos. (Crear, modificar, eliminar, activar, y buscar)"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    cadena = ""
    campo = "todos"
    items = listar_usuarios_mgr()
    if request.method == 'POST':
        if request.form["action"] == "Crear":
            return redirect(url_for('crear_usuarios'))
        if request.form["action"] == "Modificar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_modificar_usuario(seleccionados)
            if error == None: #Si paso las validaciones
                session['id_usuario_seleccionado'] = seleccionados[0]
                return redirect(url_for('modificar_usuarios'))
            else: #No paso las validaciones
                return render_template('administrar_usuarios.html', \
                items=items, id_usuario=id_usuario, error=error, \
                cadena=cadena, set_etc=campo)
        if request.form["action"] == "Eliminar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_eliminar_usuario(seleccionados)
            if error == None: #Si paso las validaciones
                error = eliminar_usuario(seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    items = listar_usuarios_mgr()
            return render_template('administrar_usuarios.html', \
            items=items, id_usuario=id_usuario, error=error, \
            cadena=cadena, set_etc=campo)
        if request.form["action"] == "Activar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_activar_usuario(seleccionados)
            if error == None: #Si paso las validaciones
                error = cambiar_estado_usuario(seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    items = listar_usuarios_mgr()
            return render_template('administrar_usuarios.html', \
            items=items, id_usuario=id_usuario, error=error, \
            cadena=cadena, set_etc=campo)
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_usuarios_mgr(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Limpiar":
            pass
        if request.form["action"] == "Salir":
            return redirect(url_for('menu_principal'))

    return render_template('administrar_usuarios.html', items=items, \
    id_usuario=id_usuario, cadena=cadena, set_etc=campo)


@app.route('/cambiar_contrasena', methods=['GET', 'POST'])
@login_required
def cambiar_contrasena():
    """Despliega la pagina del cambio de contrasena"""
    id_usuario = session['id_usuario']
    error = None
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('menu_principal'))
        pass_anterior = request.form['pass_anterior']
        pass_nuevo = request.form['pass_nuevo']
        pass_confirmacion = request.form['pass_confirmacion']
        resultado = verificar_contrasena(id_usuario, pass_anterior, \
        pass_nuevo, pass_confirmacion)
        if resultado == 'OK':
            flash("La operacion se realizo con exito")
            return redirect(url_for('menu_principal'))
        else:
            error = resultado
    return render_template('cambiar_contrasena.html', \
    id_usuario=id_usuario, error=error)

@app.route('/crear_usuarios', methods=['GET', 'POST'])
@login_required
@roles_accepted('Administrador')
def crear_usuarios():
    """Se validan los parametros ingresados para la creacion del usuario, 
    se verifica las contrasenas ingresadas y se inserta un usuario"""
    id_usuario = session['id_usuario']
    error = None
    if request.method == 'POST':

        if request.form["action"] == "Salir":
            return redirect(url_for('administrar_usuarios'))

        user = request.form['usuario']
        pass1 = request.form['contrasena']
        pass2 = request.form['contrasena2']
        name = request.form['nombre']
        lastname = request.form['apellido']
        email = request.form['correo']
        kind = request.form['tipo']

        if verificar_parametros_usuario(user, name, lastname, pass1, pass2):
            error = "Datos requeridos no ingresados"
            return render_template('crear_usuarios.html', \
            id_usuario=id_usuario, error=error, usuario=user, \
            contrasena=pass1, contrasena2=pass2, nombre=name, \
            apellido=lastname, correo=email)

        if pass1 != pass2:
            error = "Las contrasena no coincide"
            return render_template('crear_usuarios.html', \
            id_usuario=id_usuario, error=error, usuario=user, \
            contrasena=pass1, contrasena2=pass2, nombre=name, \
            apellido=lastname, correo=email)

        id_usr_creador = id_usuario

        resultado = insertar_usuario(id_usr_creador, user, name, \
        lastname, email, pass1, int(kind))

        if resultado == 'OK':
            flash("La operacion se realizo con exito")
            if request.form["action"] == "Guardar y Continuar":
                return render_template('crear_usuarios.html', \
                id_usuario=id_usuario, error=error)
            else: #Eligio Guardar
                return redirect(url_for('administrar_usuarios'))
        else:
            error = resultado
            return render_template('crear_usuarios.html', \
            id_usuario=id_usuario, error=error, usuario=user, \
            contrasena=pass1, contrasena2=pass2, nombre=name, \
            apellido=lastname, correo=email)

    return render_template('crear_usuarios.html', id_usuario = \
    id_usuario, error=error, usuario="", contrasena="", contrasena2="", \
    nombre="", apellido="", correo="")

@app.route('/modificar_usuarios', methods=['GET', 'POST'])
@login_required
@roles_accepted('Administrador')
def modificar_usuarios():
    """Se validan los parametros ingresados para la modificacion del usuario, 
    luego se almacenan los datos en la base de datos"""
    id_usuario = session['id_usuario']
    error = None
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            #Se borra la entrada en la cookie
            session.pop('id_usuario_seleccionado', None)
            return redirect(url_for('administrar_usuarios'))

        p_usuario = request.form['usuario']
        p_nombre = request.form['nombre']
        p_apellido = request.form['apellido']
        p_correo = request.form['correo']

        if verificar_parametros_modificar_usuario(p_usuario, p_nombre, p_apellido):
            error = "Datos requeridos no ingresados"
            return render_template('modificar_usuarios.html', \
            id_usuario=id_usuario, error=error, usuario=p_usuario, \
            nombre=p_nombre, apellido=p_apellido, correo=p_correo)

        resultado = modificar_usuario(id_usuario, p_usuario, p_nombre, \
        p_apellido, p_correo)

        if resultado == 'OK':
            flash("La operacion se realizo con exito")
            #Se borra la entrada en la cookie
            session.pop('id_usuario_seleccionado', None)
            return redirect(url_for('administrar_usuarios'))
        else:
            error = resultado
            return render_template('modificar_usuarios.html', \
            id_usuario=id_usuario, error=error, usuario=p_usuario, \
            nombre=p_nombre, apellido=p_apellido, correo=p_correo)

    usr_seleccionado = session['id_usuario_seleccionado']
    usr = db_session.query(Usuario).filter_by(id_usuario=\
    usr_seleccionado).one()

    return render_template('modificar_usuarios.html', id_usuario = \
    id_usuario, error=error, usuario=usr.id_usuario, \
    nombre=usr.nombre, apellido=usr.apellido, correo=usr.correo)

@app.route('/administrar_proyectos', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def administrar_proyectos():
    """Despliega la lista de proyectos del sistema, ademas de brindar
    acceso a las distintas acciones que se pueden realizar sobre los
    mismos. (Crear, modificar, eliminar, activar, y buscar)"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    cadena = ""
    campo = "todos"
    items = listar_proyectos(id_usuario)
    if request.method == 'POST':
        if request.form["action"] == "Crear":
            return redirect(url_for('crear_proyectos'))
        if request.form["action"] == "Modificar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_modificar_proyecto(seleccionados)
            if error == None: #Si paso las validaciones
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('modificar_proyectos'))
            else: #No paso las validaciones
                return render_template('administrar_proyectos.html', \
                items=items, id_usuario=id_usuario, error=error, \
                cadena=cadena, set_etc=campo)
        if request.form["action"] == "Iniciar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_iniciar_proyecto(seleccionados)
            if error == None:
                resultado = iniciar_proyecto(seleccionados[0])
                if resultado == "OK":
                    flash("La operacion se realizo con exito")
                    items = listar_proyectos(id_usuario)
                    return render_template('administrar_proyectos.html', \
                    items=items, error=error, id_usuario=id_usuario, \
                    cadena=cadena, set_etc=campo)
                else:
                    error = resultado
                    return render_template('administrar_proyectos.html', \
                    items=items, error=error, id_usuario=id_usuario, \
                    cadena=cadena, set_etc=campo)
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_proyectos(id_usuario, cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Finalizar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_finalizar_proyecto(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('finalizacion_proyecto'))
            else:
                return render_template('administrar_proyectos.html', \
                items=items, error=error, id_usuario=id_usuario, \
                cadena=cadena, set_etc=campo)
                
        if request.form["action"] == "Cancelar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_cancelar_proyecto(seleccionados)
            if error == None: #Si paso las validaciones
                error = cancelar_proyecto(seleccionados[0])
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    items = listar_proyectos(id_usuario)
            return render_template('administrar_proyectos.html', \
            items=items, id_usuario=id_usuario, error=error, \
            cadena=cadena, set_etc=campo)
        if request.form["action"] == "Salir":
            return redirect(url_for('menu_principal'))
        if request.form["action"] == "Administrar Miembros":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_administrar_miembros(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('administrar_miembros'))
        if request.form["action"] == "Administrar Fases":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_administrar_fase(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('administrar_fases'))
        if request.form["action"] == "Administrar Roles":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_administrar_roles(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('administrar_roles'))
        if request.form["action"] == "AdministrarComite":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_administrar_comite(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('administrar_comite'))

    return render_template('administrar_proyectos.html', items=items, \
    id_usuario=id_usuario, error=error, cadena=cadena, set_etc=campo)

@app.route('/crear_proyectos', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def crear_proyectos():
    """Se validan los parametros ingresados para la creacion del proyecto, 
    se verifica el presupuesto ingresado y se inserta el proyecto"""
    id_usuario = session['id_usuario']
    error = None

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('administrar_proyectos'))

        nombre = request.form['nombre']
        descripcion = request.form['descripcion']
        observacion = request.form['observacion']
        presupuesto = request.form['presupuesto']

        if not verificar_parametros_crear_proyecto(nombre, descripcion,\
        presupuesto):
            error = "Datos requeridos no ingresados"
            return render_template('crear_proyectos.html', \
            id_usuario=id_usuario, error=error, nombre=nombre, \
            descripcion=descripcion, observacion=observacion,\
            presupuesto=presupuesto)

        if not verificar_valor_presupuesto(presupuesto):
            error = "El presupuesto no es valido"
            return render_template('crear_proyectos.html', \
            id_usuario=id_usuario, error=error, nombre=nombre, \
            descripcion=descripcion, observacion=observacion,\
            presupuesto=presupuesto)

        resultado = insertar_proyecto(id_usuario, nombre, descripcion,\
        observacion, presupuesto)

        if resultado == 'OK':
            flash("La operacion se realizo con exito")
            if request.form["action"] == "Guardar y Continuar":
                return render_template('crear_proyectos.html', \
                id_usuario=id_usuario, error=error)
            else: #Eligio Guardar
                return redirect(url_for('administrar_proyectos'))
        else:
            error = resultado
            return render_template('crear_proyectos.html', \
            id_usuario=id_usuario, error=error, nombre=nombre, \
            descripcion=descripcion, observacion=observacion,\
            presupuesto=presupuesto)

    return render_template('crear_proyectos.html', id_usuario=\
    id_usuario, error=error, nombre="", descripcion="", observacion="",\
    presupuesto="")
    
@app.route('/modificar_proyectos', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def modificar_proyectos():
    """Se validan los parametros ingresados para la modificacion del proyecto, 
    luego se almacenan los datos en la base de datos"""
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    error = None
    
    proyecto = db_session.query(Proyecto).filter_by(nombre = \
    nombre_proyecto).one()
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            #Se borra la entrada en la cookie
            session.pop('nombre_proyecto', None)
            return redirect(url_for('administrar_proyectos'))

        p_nombre = request.form['nombre']
        p_descripcion = request.form['descripcion']
        p_observacion = request.form['observacion']
        p_presupuesto = request.form['presupuesto']
        p_estado = request.form['estado']
        
        resultado = validaciones_parametros_modificar_proyecto(\
        nombre_proyecto, p_nombre, p_descripcion, p_presupuesto)
        if resultado != "OK":
            error = resultado
            return render_template('modificar_proyectos.html', \
            id_usuario = id_usuario, error=error, estado_proyecto = \
            p_estado, nombre=p_nombre, descripcion=p_descripcion, 
            observacion=p_observacion, presupuesto=p_presupuesto, \
            estado=p_estado)

        resultado = modificar_proyecto(id_usuario, p_nombre, p_descripcion, \
        p_observacion, p_presupuesto)

        if resultado == 'OK':
            flash("La operacion se realizo con exito")
            #Se borra la entrada en la cookie
            session.pop('nombre_proyecto', None)
            return redirect(url_for('administrar_proyectos'))
        else:
            error = resultado
            return render_template('modificar_proyectos.html', \
            error=error, id_usuario=id_usuario, estado_proyecto=p_estado, \
            nombre=p_nombre, descripcion=p_descripcion, \
            observacion=p_observacion, \
            presupuesto=p_presupuesto, estado = p_estado)

    return render_template('modificar_proyectos.html', error=error, \
    id_usuario = id_usuario, estado_proyecto=proyecto.estado, 
    nombre=proyecto.nombre, descripcion=proyecto.descripcion, \
    presupuesto=proyecto.presupuesto,observacion=proyecto.observacion, \
    estado=proyecto.estado)

@app.route('/administrar_miembros', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def administrar_miembros():
    """Despliega la lista de usuarios miembros del proyecto, ademas de brindar
    acceso a las distintas acciones que se pueden realizar sobre los
    mismos. (Asignar miembros, desasignar miembros, asignar roles, y
    desasignar roles)"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    cadena = ""
    campo = "todos"
    items = listar_miembros()
    if request.method == 'POST':
        if request.form["action"] == "Asignar Miembros":
            return redirect(url_for('asignar_miembros'))
        if request.form["action"] == "Desasignar Miembros":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_desasignar_miembro(seleccionados)
            if error == None: #Si paso las validaciones
                error = desasignar_miembro(seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    items = listar_miembros()
            return render_template('administrar_miembros.html', \
            items=items, id_usuario=id_usuario, error=error, \
            nombre_proyecto=nombre_proyecto, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_miembros(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Asignar Roles":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_render_asignar_roles(seleccionados)
            if error == None:
                session['id_usuario_seleccionado'] = seleccionados[0]
                return redirect(url_for('asignar_roles'))
            return render_template('administrar_miembros.html', \
            items=items, id_usuario=id_usuario, error=error, \
            nombre_proyecto=nombre_proyecto, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Desasignar Roles":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_render_asignar_roles(seleccionados)
            if error == None:
                session['id_usuario_seleccionado'] = seleccionados[0]
                return redirect(url_for('desasignar_roles'))
            return render_template('administrar_miembros.html', \
            items=items, id_usuario=id_usuario, error=error, \
            nombre_proyecto=nombre_proyecto, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Salir":
            session.pop('nombre_proyecto', None)
            return redirect(url_for('administrar_proyectos'))

    return render_template('administrar_miembros.html', items=items, \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    cadena=cadena, set_etc=campo)

@app.route('/asignar_miembros', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def asignar_miembros():
    """Despliega la lista de usuarios del sistema que aun no son 
    miembros del proyecto, de manera a poder asignarlos al 
    proyecto actual"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    cadena = ""
    campo = "todos"
    items = listar_no_miembros()
    if request.method == 'POST':
        if request.form["action"] == "Asignar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_asignar_miembro(seleccionados)
            if error == None: #Si paso las validaciones
                error = asignar_miembro(seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    return redirect(url_for('administrar_miembros'))
            return render_template('asignar_miembros.html', \
            items=items, id_usuario=id_usuario, error=error, \
            nombre_proyecto=nombre_proyecto, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_no_miembros(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Salir":
            return redirect(url_for('administrar_miembros'))

    return render_template('asignar_miembros.html', items=items, \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    cadena=cadena, set_etc=campo)

@app.route('/asignar_roles', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def asignar_roles():
    """Despliega la lista de roles del proyecto que aun no han sido 
    asignados al usuario"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    cadena = ""
    campo = "todos"
    items = listar_roles_no_asignados()
    if request.method == 'POST':
        if request.form["action"] == "Asignar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_asignar_roles(seleccionados)
            if error == None: #Si paso las validaciones
                error = asignar_roles_usuario(seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    session.pop('id_usuario_seleccionado', None)
                    return redirect(url_for('administrar_miembros'))
            return render_template('asignar_roles.html', \
            items=items, id_usuario=id_usuario, error=error, \
            nombre_proyecto=nombre_proyecto, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            #items = buscar_roles_no_asignados(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Salir":
            session.pop('id_usuario_seleccionado', None)
            return redirect(url_for('administrar_miembros'))

    return render_template('asignar_roles.html', items=items, \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    cadena=cadena, set_etc=campo)

@app.route('/desasignar_roles', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def desasignar_roles():
    """Despliega la lista de roles del proyecto que han sido 
    asignados al usuario"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    cadena = ""
    campo = "todos"
    items = listar_roles_asignados()
    if request.method == 'POST':
        if request.form["action"] == "Desasignar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_asignar_roles(seleccionados)
            if error == None: #Si paso las validaciones
                error = desasignar_roles_usuario(seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    session.pop('id_usuario_seleccionado', None)
                    return redirect(url_for('administrar_miembros'))
            return render_template('desasignar_roles.html', \
            items=items, id_usuario=id_usuario, error=error, \
            cadena=cadena, set_etc=campo)
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            #items = buscar_roles_asignados(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Salir":
            session.pop('id_usuario_seleccionado', None)
            return redirect(url_for('administrar_miembros'))

    return render_template('desasignar_roles.html', items=items, \
    id_usuario=id_usuario, cadena=cadena, set_etc=campo)

@app.route('/administrar_fases', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def administrar_fases():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    cadena = ""
    campo = "todos"
    items = []
    items = listar_fases(nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_fase(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Crear":
            result = validaciones_crear_fases(nombre_proyecto)
            if result != "OK":
                error = result
                return render_template('administrar_fases.html', \
                items=items, id_usuario=id_usuario, nombre_proyecto=\
                nombre_proyecto, error=error, cadena=cadena, set_etc=campo)
            return redirect(url_for('crear_fases'))
        if request.form["action"] == "Modificar":
            seleccionados = request.form.getlist("seleccionados")
            result = validaciones_modificar_fase(seleccionados)
            if result != "OK":
                error = result
                return render_template('administrar_fases.html', \
                items=items, id_usuario=id_usuario, nombre_proyecto=\
                nombre_proyecto, error=error, cadena=cadena, set_etc=campo)
            session['nombre_fase'] = seleccionados[0]
            return redirect(url_for('modificar_fases'))
        if request.form["action"] == "Intercambiar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_intercambiar_fases(nombre_proyecto, \
            seleccionados)
            if error != None:
                return render_template('administrar_fases.html', \
                items=items, id_usuario=id_usuario, nombre_proyecto=\
                nombre_proyecto, error=error, cadena=cadena, set_etc=campo)
            error = intercambiar_fases(id_usuario, nombre_proyecto, \
            seleccionados)
            if error == "OK":
                error = None
                items = listar_fases(nombre_proyecto)
                flash("La operacion se realizo con exito")
            return render_template('administrar_fases.html', \
            items=items, id_usuario=id_usuario, nombre_proyecto=\
            nombre_proyecto, error=error, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Eliminar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_eliminar_fases(nombre_proyecto, seleccionados)
            if error == None:
                error = eliminar_fases(id_usuario, nombre_proyecto, \
                seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    items = listar_fases(nombre_proyecto)
            return render_template('administrar_fases.html', \
            items=items, id_usuario=id_usuario, nombre_proyecto=\
            nombre_proyecto, error=error, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Finalizar":
            seleccionados = request.form.getlist("seleccionados")
            result = validaciones_finalizar_fase(nombre_proyecto, \
            seleccionados)
            if result != "OK":
                error = result
                return render_template('administrar_fases.html', \
                items=items, id_usuario=id_usuario, nombre_proyecto=\
                nombre_proyecto, error=error, cadena=cadena, set_etc=campo)

            session['nombre_fase'] = seleccionados[0]
            return redirect(url_for('finalizacion_fase'))
            
        if request.form["action"] == "Importar":
            error = validaciones_boton_importar_fase(nombre_proyecto)
            if error != None:
                return render_template('administrar_fases.html', \
                items=items, id_usuario=id_usuario, nombre_proyecto=\
                nombre_proyecto, error=error, cadena=cadena, set_etc=campo)
            return redirect(url_for('importar_fases'))
        if request.form["action"] == "Salir":
            session.pop('nombre_proyecto', None)
            return redirect(url_for('administrar_proyectos'))

    return render_template('administrar_fases.html', items=items, \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, error=error,\
    cadena=cadena, set_etc=campo)

@app.route('/crear_fases', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def crear_fases():
    """Logica de validacion para la creacion de las fases"""
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    error = None
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('administrar_fases'))
        
        nombre = request.form['nombre']
        descripcion = request.form['descripcion']
        observacion = request.form['observacion']
        
        result = verificar_parametros_crear_fases(nombre_proyecto, \
        nombre, descripcion)
        if result != "OK":
            error = result
            return render_template('crear_fases.html', \
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
            error=error, nombre=nombre, descripcion=descripcion, \
            observacion=observacion) 
            
        result = insertar_fase(nombre_proyecto,nombre, descripcion, \
        observacion)
        if result != "OK":
            error = result
            return render_template('crear_fases.html', \
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
            error=error, nombre=nombre, descripcion=descripcion, \
            observacion=observacion)
            
        flash("La operacion se realizo con exito")
        if request.form["action"] == "Guardar":
            return redirect(url_for('administrar_fases'))
        else:
            return render_template('crear_fases.html', \
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,
            error=error, nombre="", descripcion="", observacion="")
        
    return render_template('crear_fases.html', id_usuario=id_usuario,\
    nombre_proyecto=nombre_proyecto, error=error, nombre="", \
    descripcion="", observacion="")

@app.route('/modificar_fases', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def modificar_fases():
    """Logica de validacion para la creacion de las fases"""
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    error = None
    
    proyecto = db_session.query(Proyecto).filter_by(nombre = \
    nombre_proyecto).one()
    fase = db_session.query(Fase).filter_by(fk_proyecto=proyecto.id).\
    filter_by(nombre = nombre_fase).one()
    
    if request.method == "POST":
        if request.form["action"] == "Salir":
            session.pop('nombre_fase', None)
            return redirect(url_for('administrar_fases'))
        nombre = request.form['nombre']
        descripcion = request.form['descripcion']
        observacion = request.form['observacion']
        estado = request.form['estado']
        orden = request.form['orden']
        
        result = validaciones_parametros_modificar_fase(nombre_proyecto,\
        nombre_fase, nombre, descripcion)
        if result != "OK":
            error = result
            return render_template('modificar_fases.html', \
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            error=error, estado_fase = estado, nombre=nombre, \
            descripcion=descripcion, observacion=observacion, \
            estado=estado, orden=orden)
        
        result = modificar_fase(nombre_proyecto, nombre_fase, nombre, \
        descripcion, observacion)
        if result != "OK":
            error = result
            return render_template('modificar_fases.html', \
            id_usuario=id_usuario,nombre_proyecto=nombre_proyecto, \
            error=error, estado_fase=estado, nombre=nombre, \
            descripcion=descripcion, observacion=observacion, \
            estado=estado, orden=orden)
            
        flash("La operacion se realizo con exito")
        session.pop('nombre_fase', None)
        return redirect(url_for('administrar_fases'))

    return render_template('modificar_fases.html', id_usuario=id_usuario,\
    nombre_proyecto=nombre_proyecto, error=error, \
    estado_fase=fase.estado, nombre=fase.nombre, \
    descripcion=fase.descripcion, observacion=fase.observacion, \
    estado=fase.estado, orden=fase.orden)

@app.route('/importar_fases', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def importar_fases():
    """Despliega una lista con las fases de los distintos proyectos 
    de los cuales es lider. Selecciona una o varias para importarlas 
    al proyecto actual"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    cadena = ""
    campo = "todos"
    items = listar_fases_a_importar(id_usuario)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop('nombre_fase', None)
            return redirect(url_for('administrar_fases'))
        if request.form["action"] == "Importar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_importar_fase(seleccionados)
            if error != None:
                return render_template('importar_fases.html', id_usuario=\
                id_usuario, items=items, nombre_proyecto=\
                nombre_proyecto, error=error)
            error = realizar_importacion_fases(id_usuario, nombre_proyecto, seleccionados)
            if error != 'OK':
                return render_template('importar_fases.html', id_usuario=\
                id_usuario, items=items, nombre_proyecto=\
                nombre_proyecto, error=error)
            flash("La operacion se realizo con exito")
            return redirect(url_for('administrar_fases'))

    return render_template('importar_fases.html', id_usuario=id_usuario,\
    items=items, nombre_proyecto=nombre_proyecto, error=error)

@app.route('/administrar_roles', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def administrar_roles():
    """Despliega la lista de roles del proyecto, ademas de brindar
    acceso a las distintas acciones que se pueden realizar sobre los
    mismos (Crear, Modificar, y Eliminar)."""
    items = []
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    cadena = ""
    campo = "todos"
    items = listar_roles_proyecto()
    if request.method == 'POST':
        if request.form["action"] == "Crear":
            error = validaciones_boton_crear_rol(nombre_proyecto)
            if error == None:
                return redirect(url_for('crear_roles'))
        if request.form["action"] == "Modificar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_modificar_rol(seleccionados)
            if error == None: #Si paso las validaciones
                session['id_rol_seleccionado'] = seleccionados[0]
                return redirect(url_for('modificar_roles'))
            return render_template('administrar_roles.html', \
            items=items, id_usuario=id_usuario, error=error, \
            nombre_proyecto=nombre_proyecto, cadena=cadena, set_etc=campo)
        if request.form["action"] == "Eliminar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_eliminar_roles(seleccionados)
            if error == None: #Si paso las validaciones
                error = eliminar_rol(seleccionados)
                if error == "OK":
                    error = None
                    flash("La operacion se realizo con exito")
                    items = listar_roles_proyecto()
            return render_template('administrar_roles.html', \
            items=items, id_usuario=id_usuario, error=error, \
            cadena=cadena, set_etc=campo, nombre_proyecto=\
            nombre_proyecto)
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_roles_proyecto(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Salir":
            session.pop('nombre_proyecto', None)
            return redirect(url_for('administrar_proyectos'))

    return render_template('administrar_roles.html', items=items, \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    cadena=cadena, set_etc=campo, error=error)

@app.route('/crear_roles', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def crear_roles():
    """Se validan los parametros ingresados para la creacion del rol"""
    id_usuario = session['id_usuario']
    error = None
    fases = []
    permisos = []
    fases = listar_fases_crear_roles()
    permisos = listar_permisos()

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('administrar_roles'))

        nombre = request.form["nombre"]
        descripcion = request.form["descripcion"]
        observacion = request.form["observacion"]
        fase = request.form["select_fase"]
        permisos_selec = request.form.getlist("permisos_selec")

        error = verificar_parametros_crear_rol(nombre, descripcion, \
        permisos_selec)

        if error != None:
            return render_template('crear_roles.html', id_usuario=\
            id_usuario, error=error, nombre=nombre, descripcion=\
            descripcion, observacion=observacion, fases=fases, \
            permisos=permisos)

        error = crear_rol(nombre, descripcion, observacion, fase, \
        permisos_selec)

        if error != "OK":
            return render_template('crear_roles.html', id_usuario=\
            id_usuario, error=error, nombre=nombre, descripcion=\
            descripcion, observacion=observacion, fases=fases, \
            permisos=permisos)

        flash("La operacion se realizo con exito")
        error = None
        if request.form["action"] == "Guardar":
            return redirect(url_for('administrar_roles'))

    return render_template('crear_roles.html', id_usuario=\
    id_usuario, error=error, nombre="", descripcion="", observacion="",\
    fases=fases, permisos=permisos)

@app.route('/modificar_roles', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def modificar_roles():
    """Se validan los parametros ingresados para la modificacion del rol"""
    id_usuario = session['id_usuario']
    error = None
    fases = []
    permisos = []
    fases = listar_fases_crear_roles()
    permisos = listar_permisos()

    rol_seleccionado = int(session['id_rol_seleccionado'])
    rol = db_session.query(Rol).filter_by(id=rol_seleccionado).one()

    fase_actual = rol.fase.id
    permisos_actuales = rol.permisos
    lista_permisos = []
    for permiso in permisos_actuales:
        lista_permisos.append(permiso.id)

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop('id_rol_seleccionado', None)
            return redirect(url_for('administrar_roles'))

        nombre = request.form["nombre"]
        descripcion = request.form["descripcion"]
        observacion = request.form["observacion"]
        fase = request.form["select_fase"]
        permisos_selec = request.form.getlist("permisos_selec")

        error = verificar_parametros_modificar_rol(nombre, descripcion, \
        permisos_selec)

        if error != None:
            list_perms = []
            for permiso in permisos_selec:
                list_perms.append(int(permiso))

            return render_template('modificar_roles.html', id_usuario=\
            id_usuario, error=error, nombre=nombre, descripcion=\
            descripcion, observacion=observacion, fases=fases, \
            permisos=permisos, fase_actual=fase_actual, lista_permisos=\
            list_perms)

        error = modificar_rol(nombre, descripcion, observacion, fase, \
        permisos_selec)

        if error != "OK":
            list_perms = []
            for permiso in permisos_selec:
                list_perms.append(int(permiso))

            return render_template('modificar_roles.html', id_usuario=\
            id_usuario, error=error, nombre=nombre, descripcion=\
            descripcion, observacion=observacion, fases=fases, \
            permisos=permisos, fase_actual=fase_actual, lista_permisos=\
            list_perms)

        flash("La operacion se realizo con exito")
        error = None
        return redirect(url_for('administrar_roles'))

    return render_template('modificar_roles.html', id_usuario=\
    id_usuario, error=error, nombre=rol.nombre, descripcion=\
    rol.descripcion, observacion=rol.observacion, fases=fases, \
    permisos=permisos, fase_actual=fase_actual, lista_permisos=\
    lista_permisos)

@app.route('/desarrollo_proyectos', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider', 'Usuario')
def desarrollo_proyectos():
    """Lista los proyectos de los cuales el usuario es miembro, para 
    trabajar en las distintas tareas"""
    id_usuario = session['id_usuario']
    error = None
    cadena = ""
    campo = "todos"
    items = listar_proyectos_desarrollo(id_usuario)

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('menu_principal'))
        if request.form["action"] == "Fases":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_desarrollo_fases(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('desarrollo_fases'))
        if request.form["action"] == "Solicitud de Cambio":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_desarrollo_solicitud(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('solicitud_de_cambio'))
        if request.form["action"] == "Reporte Items":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_desarrollo_fases(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('reporte_items_proyecto'))
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_proyectos_desarrollo(id_usuario, cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Limpiar":
            pass
        if request.form["action"] == "Crear Grafo":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_crear_grafo(seleccionados)
            if error == None:
                session['nombre_proyecto'] = seleccionados[0]
                return redirect(url_for('crear_grafo'))            


    return render_template('desarrollo_proyectos.html', id_usuario=\
    id_usuario, error=error, cadena=cadena, set_etc=campo, \
    items=items)

@app.route('/desarrollo_fases', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider', 'Usuario')
def desarrollo_fases():
    """Lista las fases del proyecto seleccionado, para trabajar en 
    las distintas tareas"""
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    error = None
    cadena = ""
    campo = "todos"
    items = listar_fases_desarrollo(nombre_proyecto)

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop('nombre_proyecto', None)
            return redirect(url_for('desarrollo_proyectos'))
        if request.form["action"] == "Tipo Item":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_desarrollo_tipoitem(seleccionados)
            if error == None:
                session["nombre_fase"] = seleccionados[0]
                return redirect(url_for('desarrollo_tipoitem'))
        if request.form["action"] == "Item":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_desarrollo_item(seleccionados)
            if error == None:
                session["nombre_fase"] = seleccionados[0]
                return redirect(url_for('desarrollo_item'))
        if request.form["action"] == "Linea Base":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_desarrollo_linea_base(seleccionados)
            if error == None:
                session["nombre_fase"] = seleccionados[0]
                return redirect(url_for('desarrollo_linea_base'))
                
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_fases_desarrollo(nombre_proyecto, cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Limpiar":
            pass

    return render_template('desarrollo_fases.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    cadena=cadena, set_etc=campo, items=items)

@app.route('/desarrollo_tipoitem', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Tipo Item', 'Modificar Tipo Item', \
'Eliminar Tipo Item')
def desarrollo_tipoitem():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    cadena = ""
    campo = "todos"
    items = []
    items = listar_tipo_item(nombre_fase, nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_tipoitem(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Crear":
            error = validaciones_boton_crear_tipoitem(nombre_proyecto, \
            nombre_fase)
            if error == None:
                atributo = {}
                session['atributo'] = atributo
                atributos = []
                session['atributos'] = atributos
                return redirect(url_for('crear_tipoitem'))
            
        if request.form["action"] == "Modificar":
            seleccionados = request.form.getlist("seleccionados")
            result = validaciones_modificar_tipoitem(seleccionados, \
            nombre_proyecto, nombre_fase)
            if result != "OK":
                error = result
                return render_template('desarrollo_tipoitem.html', items=items,\
                id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
                nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
                error=error)
            
            session['id'] = None
            atributo = {}
            session['atributo'] = atributo
            atributos = []
            session['atributos'] = atributos
            session['nombre_tipoitem'] = seleccionados[0]
            return redirect(url_for('modificar_tipoitem'))
            
        if request.form["action"] == "Importar":
            result = validaciones_proyecto_importar_tiposItem(nombre_proyecto,\
            nombre_fase)
            if result != "OK":
                error = result
                return render_template('desarrollo_tipoitem.html', items=items,\
                id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
                nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
                error=error)
            
            return redirect(url_for('importar_tipositem'))
                
        if request.form["action"] == "Eliminar":
            seleccionados = request.form.getlist("seleccionados")
            result = validaciones_eliminar_tipoitem(id_usuario, \
            nombre_proyecto, nombre_fase, seleccionados)
            if result != "OK":
                error = result
                return render_template('desarrollo_tipoitem.html', items=items,\
                id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
                nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
                error=error)
                
            result = eliminar_tipositem(nombre_proyecto, nombre_fase,\
            seleccionados)
            if result != "OK":
                error = result
                return render_template('desarrollo_tipoitem.html', items=items,\
                id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
                nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
                error=error)
            
            flash("La operacion se realizo con exito")
            items = listar_tipo_item(nombre_fase, nombre_proyecto)
            return render_template('desarrollo_tipoitem.html', items=items,\
            id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
            error=error)    
                
        if request.form["action"] == "Salir":
            session.pop('nombre_fase', None)
            return redirect(url_for('desarrollo_fases'))

    return render_template('desarrollo_tipoitem.html', items=items, \
    id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, error=\
    error)

@app.route('/crear_tipoitem', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Tipo Item')
def crear_tipoitem():
    
    error=None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    items = session['atributos']
    tipoatributo="2"
    if request.method=='POST':
        if request.form['action']=='Salir':
            items = []
            session['atributos'] = items
            session.pop('atributos', None)
            return redirect(url_for('desarrollo_tipoitem'))
        
        nombre = request.form["nombre"]
        descripcion = request.form["descripcion"]
        observacion = request.form["observacion"]
        
        nombreatributo = request.form["nombreatributo"]
        descripcionatributo = request.form["descripcionatributo"]
        observacionatributo = request.form["observacionatributo"]
        tipoatributo = request.form["tipoatributos"]
        longitudatributo = request.form['longitudatributo']
        precisionatributo = request.form['precisionatributo']
        obligatorio = request.form["obligatorio"]
        
        if request.form['action']=='Agregar':
            result = validaciones_parametros_agregar_atributos(\
            nombreatributo, descripcionatributo, tipoatributo,\
            longitudatributo, precisionatributo, items)
            if result != "OK":
                error = result
                return render_template('crear_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre, \
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,\
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo)
            
            result = agregar_atributo(nombreatributo, descripcionatributo,\
            observacionatributo, tipoatributo, obligatorio,\
            longitudatributo, precisionatributo, items)
            if result != "OK":
                error = result
                return render_template('crear_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,\
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo)
            
            atrib = {}
            session['atributo'] = atrib
            session['atributos'] = items
            return render_template('crear_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo="2", set_obligatorio="N", nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo="", descripcionatributo="",\
            observacionatributo="", longitudatributo="",
            precisionatributo="")
            
        if request.form['action']=='Eliminar':
            seleccionados = request.form.getlist("seleccionados")
            result = validaciones_eliminar_atributos(seleccionados)
            if result != "OK":
                error = result
                return render_template('crear_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,\
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo)
            
            result = eliminar_atributos(seleccionados[0], items)
            if result != "OK":
                error = result
                return render_template('crear_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo)
            
            session['atributos'] = items
            return render_template('crear_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo=nombreatributo,\
            descripcionatributo=descripcionatributo,\
            observacionatributo=observacionatributo,
            longitudatributo=longitudatributo,\
            precisionatributo=precisionatributo)

        if request.form['action']=='Modificar':
            atrib = session['atributo']
            seleccionados = request.form.getlist("seleccionados")
            result =  validaciones_modificar_atributos(seleccionados, atrib)
            if result != "OK":
                if len(atrib) > 0:
                    tipoatributo = obtener_tipoatributo(atrib['tipo'])
                    obligatorio = atrib['obligatorio']
                    nombreatributo = atrib['nombre']
                    descripcionatributo = atrib['descripcion']
                    longitudatributo=atrib['longitud']
                    precisionatributo=atrib['precision']
                    observacionatributo=atrib['observacion']

                error = result
                return render_template('crear_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio,\
                nombre=nombre, descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo, descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo, longitudatributo= longitudatributo,\
                precisionatributo=precisionatributo)

            result = modificar_atributo(seleccionados[0], items, atrib)
            if result != "OK":
                if len(atrib) > 0:
                    tipoatributo = obtener_tipoatributo(atrib['tipo'])
                    obligatorio = atrib['obligatorio']
                    nombreatributo = atrib['nombre']
                    descripcionatributo = atrib['descripcion']
                    longitudatributo=atrib['longitud']
                    precisionatributo=atrib['precision']
                    observacionatributo=atrib['observacion']
                    
                error = result
                tipo = obtener_tipoatributo(atrib['tipo'])
                return render_template('crear_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipo, set_obligatorio=obligatorio,\
                nombre=nombre, descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo, descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo, longitudatributo= longitudatributo,\
                precisionatributo=precisionatributo)

            session['atributo'] = atrib
            session['atributos'] = items
            tipo = obtener_tipoatributo(atrib['tipo'])          
            return render_template('crear_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipo, set_obligatorio=atrib['obligatorio'],\
            nombre=nombre, descripcion=descripcion, observacion=observacion,\
            nombreatributo=atrib['nombre'], descripcionatributo=atrib['descripcion'],\
            observacionatributo=atrib['observacion'], longitudatributo=atrib['longitud'],\
            precisionatributo=atrib['precision'])
        
        result = validaciones_parametros_crear_tipositem(nombre_proyecto, nombre_fase,\
        nombre, descripcion, nombreatributo, descripcionatributo, 
        observacionatributo, items)
        if result != "OK":
            error = result
            return render_template('crear_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo=nombreatributo,\
            descripcionatributo=descripcionatributo,\
            observacionatributo=observacionatributo)

        result = insertar_tipositem(id_usuario, nombre_proyecto, \
        nombre_fase, nombre, descripcion, observacion, items)
        if result != "OK":
            error = result
            return render_template('crear_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo=nombreatributo,\
            descripcionatributo=descripcionatributo,\
            observacionatributo=observacionatributo)
        
        session.pop('atributos', None)
        flash("La operacion se realizo con exito")
        if request.form['action']=='Guardar y Continuar':
            items = []
            session['atributos'] = items
            return render_template('crear_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre='', descripcion='',\
            observacion='', nombreatributo='', descripcionatributo='',\
            observacionatributo='')
            
        return redirect(url_for('desarrollo_tipoitem'))
            
    return render_template('crear_tipoitem.html', id_usuario=id_usuario,\
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
    error=error, items=items, set_tipo=tipoatributo, set_obligatorio="N" ,\
    nombre='', descripcion='', observacion='', nombreatributo='', \
    descripcionatributo='', observacionatributo='')


@app.route('/modificar_tipoitem', methods=['GET', 'POST'])
@login_required
@roles_accepted('Modificar Tipo Item')
def modificar_tipoitem():
    
    error=None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    nombre_tipoitem = session['nombre_tipoitem']
    tipoatributo="2"

    tipoitem = obtener_tipo_item( nombre_proyecto, nombre_fase, 
    nombre_tipoitem)
    atributos = listar_atributos( nombre_proyecto, nombre_fase, 
    nombre_tipoitem)
    estado = obtener_estado_fase( nombre_proyecto, nombre_fase)
    
    items = session['atributos']
    if len(items) == 0:
        for atributo in atributos:
            if atributo.tipo == 1:
                tipo = "Numerico"
            if atributo.tipo == 2:
                tipo = "Cadena"
            if atributo.tipo == 3:
                tipo = "Fecha"
            if atributo.tipo == 4:
                tipo = "Binario"
        
            item = dict(id=atributo.id, nombre=atributo.nombre, descripcion=atributo.descripcion,\
            observacion=atributo.observacion, tipo=tipo, longitud=atributo.longitud,\
            precision=atributo.precision, obligatorio=atributo.obligatorio)
            items.append(item)

    if request.method=='POST':
        if request.form['action']=='Salir':
            items = []
            session['atributos'] = items
            session.pop('atributos', None)
            session.pop('nombre_tipoitem', None)
            session.pop('id', None)
            return redirect(url_for('desarrollo_tipoitem'))    

        nombre = request.form["nombre"]
        descripcion = request.form["descripcion"]
        observacion = request.form["observacion"]
        
        nombreatributo = request.form["nombreatributo"]
        descripcionatributo = request.form["descripcionatributo"]
        observacionatributo = request.form["observacionatributo"]
        tipoatributo = request.form["tipoatributos"]
        longitudatributo = request.form['longitudatributo']
        precisionatributo = request.form['precisionatributo']
        obligatorio = request.form["obligatorio"]
        
        if request.form['action']=='Agregar':
            result = validaciones_parametros_agregar_atributos(\
            nombreatributo, descripcionatributo, tipoatributo,\
            longitudatributo, precisionatributo, items)
            if result != "OK":
                error = result
                return render_template('modificar_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre, \
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo, \
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo, estado_fase=estado)
            
            result = agregar_atributo_modificacion(nombreatributo, descripcionatributo,\
            observacionatributo, tipoatributo, obligatorio, longitudatributo,\
            precisionatributo, items)
            if result != "OK":
                error = result
                return render_template('modificar_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,\
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo, estado_fase=estado)
            
            atrib = {}
            session['id'] = None
            session['atributo'] = atrib
            session['atributos'] = items
            return render_template('modificar_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo="2", set_obligatorio='N', nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo="", descripcionatributo="",\
            observacionatributo="", longitudatributo="",\
            precisionatributo="", estado_fase=estado)
            
        if request.form['action']=='Eliminar':
            seleccionados = request.form.getlist("seleccionados")
            result = validaciones_eliminar_atributos(seleccionados)
            if result != "OK":
                error = result
                return render_template('modificar_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,\
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo, estado_fase=estado)
            
            result = eliminar_atributos(seleccionados[0], items)
            if result != "OK":
                error = result
                return render_template('modificar_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
                descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo,\
                descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,\
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo, estado_fase=estado)
            
            session['atributos'] = items
            return render_template('modificar_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio=obligatorio, nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo=nombreatributo,\
            descripcionatributo=descripcionatributo,\
            observacionatributo=observacionatributo,\
            longitudatributo=longitudatributo,\
            precisionatributo=precisionatributo, estado_fase=estado)
        
        if request.form['action']=='Modificar':
            atrib = session['atributo']
            seleccionados = request.form.getlist("seleccionados")
            result =  validaciones_modificar_atributos(seleccionados, atrib)
            if result != "OK":
                error = result
                if len(atrib) > 0:
                    tipoatributo = obtener_tipoatributo(atrib['tipo'])
                    obligatorio = atrib['obligatorio']
                    nombreatributo = atrib['nombre']
                    descripcionatributo = atrib['descripcion']
                    longitudatributo=atrib['longitud']
                    precisionatributo=atrib['precision']
                    observacionatributo=atrib['observacion']
                
                return render_template('modificar_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=obligatorio,\
                nombre=nombre, descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo, descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo,\
                longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo, estado_fase=estado)

            result = modificar_atributo_modificacion(seleccionados[0], items, atrib)
            if result != "OK":
                error = result
                if len(atrib) > 0:
                    tipoatributo = obtener_tipoatributo(atrib['tipo'])
                    obligatorio = atrib['obligatorio']
                    nombreatributo = atrib['nombre']
                    descripcionatributo = atrib['descripcion']
                    longitudatributo=atrib['longitud']
                    precisionatributo=atrib['precision']
                    observacionatributo=atrib['observacion']
                    
                return render_template('modificar_tipoitem.html',\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error, items=items, \
                set_tipo=tipoatributo, set_obligatorio=atrib['obligatorio'],\
                nombre=nombre, descripcion=descripcion, observacion=observacion,\
                nombreatributo=nombreatributo, descripcionatributo=descripcionatributo,\
                observacionatributo=observacionatributo, longitudatributo=longitudatributo,\
                precisionatributo=precisionatributo, estado_fase=estado)

            session['atributo'] = atrib
            session['atributos'] = items
            tipoatributo = obtener_tipoatributo(atrib['tipo'])          
            return render_template('modificar_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio=atrib['obligatorio'],\
            nombre=nombre, descripcion=descripcion, observacion=observacion,\
            nombreatributo=atrib['nombre'], descripcionatributo=atrib['descripcion'],\
            observacionatributo=atrib['observacion'], longitudatributo=atrib['longitud'],\
            precisionatributo=atrib['precision'], estado_fase=estado)
        
        result = validaciones_parametros_modificar_tipositem(\
        nombre_proyecto, nombre_fase, nombre_tipoitem, nombre,\
        descripcion, nombreatributo, descripcionatributo, \
        observacionatributo, items)
        if result != "OK":
            error = result
            return render_template('modificar_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio='N', nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo=nombreatributo,\
            descripcionatributo=descripcionatributo,\
            observacionatributo=observacionatributo,\
            longitudatributo=longitudatributo,\
            precisionatributo=precisionatributo, estado_fase=estado)
        
        result = modificar_tipositem(id_usuario, nombre_proyecto, \
        nombre_fase, nombre_tipoitem, nombre, descripcion,\
        observacion, items)
        if result != "OK":
            error = result
            return render_template('modificar_tipoitem.html',\
            id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
            nombre_fase=nombre_fase, error=error, items=items, \
            set_tipo=tipoatributo, set_obligatorio='N', nombre=nombre,\
            descripcion=descripcion, observacion=observacion,\
            nombreatributo=nombreatributo,\
            descripcionatributo=descripcionatributo,\
            observacionatributo=observacionatributo,\
            longitudatributo=longitudatributo,\
            precisionatributo=precisionatributo, estado_fase=estado)
        
        session.pop('atributos', None)
        flash("La operacion se realizo con exito")
        return redirect(url_for('desarrollo_tipoitem'))
        
    return render_template('modificar_tipoitem.html', id_usuario=id_usuario,\
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
    error=error, items=items, set_tipo='2', set_obligatorio='N',\
    nombre=tipoitem.nombre, descripcion=tipoitem.descripcion, \
    observacion=tipoitem.observacion, nombreatributo='', \
    descripcionatributo='', observacionatributo='',\
    longitudatributo='', precisionatributo= '', estado_fase=estado)

@app.route('/desarrollo_item', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Item', 'Modificar Item', 'Eliminar Item', \
'Revivir Item', 'Revertir Item', 'Aprobar Item', 'Activar Item')
def desarrollo_item():
    """Despliega la lista de los items del proyecto, ademas de brindar
    acceso a las distintas acciones que se pueden realizar sobre los
    mismos (Crear, Modificar, Eliminar, Revivir, Revertir, Activar y 
    Aprobar)."""
    items = []
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    nombre_fase = session["nombre_fase"]
    cadena = ""
    campo = "todos"
    items = listar_item(nombre_fase, nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_items(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Crear":
            error = validaciones_boton_crear_item(nombre_proyecto, \
            nombre_fase)
            if error == None:
                return redirect(url_for('crear_item'))
        if request.form["action"] == "Modificar":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_modificar_item(seleccionados)
            if error == None:
                id_item = int(seleccionados[0])
                id_tipo_item = obtener_id_tipo_item(id_item)
                session["id_item"] = id_item
                session["id_tipo_item"] = id_tipo_item
                return redirect(url_for('modificar_item'))
        if request.form["action"] == "Eliminar":
            seleccionados = request.form.getlist("seleccionados")
            result = verificar_seleccionado_eliminar_item(seleccionados)
            if result != "OK":
                error = result
                return render_template('desarrollo_items.html', items=items, \
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
                nombre_fase=nombre_fase,cadena=cadena, set_etc=campo,\
                error=error)
            
            id_item = int(seleccionados[0])
            id_tipo_item = obtener_id_tipo_item(id_item)
            session["id_item"] = id_item
            session["id_tipo_item"] = id_tipo_item
            return redirect(url_for('eliminar_item'))
            
        if request.form["action"] == "Revivir":
           return redirect(url_for('revivir_item'))
           
        if request.form["action"] == "Revertir":
            seleccionados = request.form.getlist("seleccionados")
            result = validacion_seleccionados_revertir_item(seleccionados)
            if result != "OK":
                error = result
                return render_template('desarrollo_items.html', items=items, \
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
                nombre_fase=nombre_fase,cadena=cadena, set_etc=campo,\
                error=error)
            id_item = seleccionados[0]
            id_item_numerico = int(id_item)
            session["id_item"] = id_item_numerico
            return redirect(url_for('revertir_item'))

        if request.form["action"] == "Finalizar":
            seleccionados = request.form.getlist("seleccionados")
            error = validacion_estado_finalizado(seleccionados)
            if error == None:
                error = establecer_finalizado(seleccionados)
                if error == "OK":
                    error = None
                    items = listar_item(nombre_fase, nombre_proyecto)
                    flash("La operacion se realizo con exito")
        if request.form["action"] == "Aprobar":
            seleccionados = request.form.getlist("seleccionados")
            error = validacion_aprobar_item(seleccionados, nombre_fase,\
            nombre_proyecto)
            if error == None:
                error = aprobar_item(seleccionados)
                if error == 'OK':
                    error = None
                    items = listar_item(nombre_fase, nombre_proyecto)
                    flash("La operacion se realizo con exito")
        if request.form["action"] == "Activar":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_activar_item(seleccionados)
            if error == None:
                error = activar_item(id_usuario, seleccionados)
                if error == 'OK':
                    error = None
                    flash('La operacion se realizo con exito')
                    items = listar_item(nombre_fase, nombre_proyecto)
        if request.form["action"] == "Salir":
            session.pop('nombre_fase', None)
            return redirect(url_for('desarrollo_fases'))
        if request.form["action"] == "Ver Relaciones":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_ver_relaciones(seleccionados)
            if error == None:
                session['id_item'] = seleccionados[0]
                return redirect(url_for('ver_relaciones'))
        if request.form["action"] == "Crear Relacion":
           return redirect(url_for('crear_relacion'))
        if request.form["action"] == "Eliminar Relacion":
            seleccionados = request.form.getlist("seleccionados")
            result = validar_seleccionados_eliminar_relacion(seleccionados)
            if result != "OK":
                error = result
                return render_template('desarrollo_items.html', items=items, \
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
                nombre_fase=nombre_fase,cadena=cadena, set_etc=campo,\
                error=error)

            id_item = int(seleccionados[0])
            session["id_item"] = id_item  
            return redirect(url_for('eliminar_relacion'))

        if request.form["action"] == "Calculo de Impacto":
            seleccionados = request.form.getlist("seleccionados")
            result = verificar_parametros_calculo_impacto(seleccionados)
            if result != "OK":
                error = result
                return render_template('desarrollo_items.html', items=items,\
                id_usuario=id_usuario, nombre_proyecto=nombre_proyecto,\
                nombre_fase=nombre_fase, error=error)
                
            id_item = seleccionados[0]
            id_item_numerico = int(id_item)
            flash('Calculo de Impacto por la izquierda: ' + str(\
            calculo_impacto_hacia_atras(id_item_numerico)))
            flash('Calculo de Impacto por la derecha: ' + str(\
            calculo_impacto_hacia_adelante(id_item_numerico)))
            flash('Calculo de Impacto total: ' + str(\
            calculo_impacto_total(id_item_numerico)))

        if request.form["action"] == "Subir Archivo":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_boton_subirarchivo(seleccionados)
            if error == None:
                id_item = int(seleccionados[0])
                session["id_item"] = id_item  
                return redirect(url_for('subir_archivo'))

        if request.form["action"] == "Descargar Archivo":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_boton_descargararchivo(seleccionados)
            if error == None:
                id_item = int(seleccionados[0])
                session["id_item"] = id_item  
                return redirect(url_for('descargar_archivo'))

        if request.form["action"] == "Reporte Historial":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_boton_reporte_historial(seleccionados)
            if error == None:
                id_item = int(seleccionados[0])
                session["id_item"] = id_item  
                return redirect(url_for('reporte_historial_item'))
        
        if request.form["action"] == "Crear Grafo":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_crear_grafo_item(seleccionados)
            if error == None:
                id_item = int(seleccionados[0])
                session["id_item"] = id_item  
                return redirect(url_for('ConstruirGrafos'))

    return render_template('desarrollo_items.html', items=items, \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    nombre_fase=nombre_fase,cadena=cadena, set_etc=campo, error=error)

@app.route('/crear_item', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Item')
def crear_item():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    tipo_actual = None
    tipos_item = listar_tipoitem_crear_item(nombre_proyecto, nombre_fase)
    if request.method == 'POST':
        try:
            if request.form["action"] == "Prueba":
                pass
        except:
            #Entra aqui cuando el form no contiene ningun action, 
            #es decir, el post vino del value change de la lista
            id_tipo_item = request.form['select_tipoitem']
            id_tipo_item_numerico = int(id_tipo_item)
            nombre = request.form['nombre']
            descripcion = request.form['descripcion']
            observacion = request.form['observacion']
            complejidad = request.form['complejidad']
            costo = request.form['costo']
            atributos = traer_atributos_tipoitem(id_tipo_item_numerico)

            return render_template('crear_item.html', id_usuario=id_usuario, \
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
            error=error, tipo_actual=id_tipo_item_numerico, tipos_item=\
            tipos_item, nombre=nombre, descripcion=descripcion, \
            observacion=observacion, complejidad=complejidad, costo=costo, \
            atributos=atributos)

        if request.form["action"] == "Salir":
            return redirect(url_for('desarrollo_item'))

        #Se selecciono Guardar o Guardar y Continuar
        id_tipo_item = request.form['select_tipoitem']
        id_tipo_item_numerico = int(id_tipo_item)
        nombre = request.form['nombre']
        descripcion = request.form['descripcion']
        observacion = request.form['observacion']
        complejidad = request.form['complejidad']
        costo = request.form['costo']
        atributos = traer_atributos_tipoitem(id_tipo_item_numerico)
        lista_atributos = []
        for atributo in atributos:
            pk = atributo['id']
            valor = request.form[str(atributo['id'])]
            item = dict(pk=pk, valor=valor)
            lista_atributos.append(item)
        error = validaciones_parametros_item(id_tipo_item_numerico, \
        nombre_proyecto, nombre_fase, nombre, descripcion, \
        complejidad, costo, lista_atributos)
        if error != None:
            atributos = cargar_valores_atributos(atributos, \
            lista_atributos)

            return render_template('crear_item.html', id_usuario=\
            id_usuario, nombre_proyecto=nombre_proyecto, \
            nombre_fase=nombre_fase, error=error, tipo_actual=\
            id_tipo_item_numerico, tipos_item=tipos_item, nombre=\
            nombre, descripcion=descripcion, observacion=\
            observacion, complejidad=complejidad, costo=costo, \
            atributos=atributos)

        error = insertar_item(id_tipo_item_numerico, \
        nombre_proyecto, nombre_fase, id_usuario, nombre, \
        descripcion, observacion, complejidad, costo, \
        lista_atributos)
        if error != 'OK':
            atributos = cargar_valores_atributos(atributos, \
            lista_atributos)

            return render_template('crear_item.html', id_usuario=\
            id_usuario, nombre_proyecto=nombre_proyecto, \
            nombre_fase=nombre_fase, error=error, tipo_actual=\
            id_tipo_item_numerico, tipos_item=tipos_item, nombre=\
            nombre, descripcion=descripcion, observacion=\
            observacion, complejidad=complejidad, costo=costo, \
            atributos=atributos)
        else:
            error = None
            flash("La operacion se realizo con exito")

        if request.form["action"] == "Guardar":
            return redirect(url_for('desarrollo_item'))

    return render_template('crear_item.html', id_usuario=id_usuario, \
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
    error=error, tipos_item=tipos_item)

@app.route('/modificar_item', methods=['GET', 'POST'])
@login_required
@roles_accepted('Modificar Item')
def modificar_item():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    id_item = session["id_item"]
    id_item_numerico = int(id_item)
    id_tipo_item = session["id_tipo_item"]
    id_tipo_item_numerico = int(id_tipo_item)
    tipo_item = obtener_nombre_tipo_item(id_tipo_item_numerico)
    atributos = traer_atributos_tipoitem(id_tipo_item_numerico)
    lista_atributos = []
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop('id_item', None)
            session.pop('id_tipo_item', None)
            return redirect(url_for('desarrollo_item'))

        if request.form["action"] == "Guardar":
            nombre = request.form['nombre']
            descripcion = request.form['descripcion']
            observacion = request.form['observacion']
            complejidad = request.form['complejidad']
            costo = request.form['costo']

            for atributo in atributos:
                pk = atributo['id']
                valor = request.form[str(atributo['id'])]
                item = dict(pk=pk, valor=valor)
                lista_atributos.append(item)
            error = validaciones_parametros_modificar_item(\
            id_tipo_item_numerico, nombre_proyecto, nombre_fase, nombre, \
            descripcion, complejidad, costo, lista_atributos, id_item_numerico)
            if error != None:
                atributos = cargar_valores_atributos(atributos, \
                lista_atributos)

                return render_template('modificar_item.html', id_usuario=\
                id_usuario, nombre_proyecto=nombre_proyecto, \
                nombre_fase=nombre_fase, error=error, tipo_item=\
                tipo_item, nombre=nombre, descripcion=descripcion, \
                observacion=observacion, complejidad=complejidad, \
                costo=costo, atributos=atributos)

            error = modificacion_item(id_item_numerico, \
            nombre_proyecto, nombre_fase, id_usuario, nombre, \
            descripcion, observacion, complejidad, costo, \
            lista_atributos)

            if error != 'OK':
                atributos = cargar_valores_atributos(atributos, \
                lista_atributos)

                return render_template('modificar_item.html', id_usuario=\
                id_usuario, nombre_proyecto=nombre_proyecto, \
                nombre_fase=nombre_fase, error=error, tipo_item=\
                tipo_item, nombre=nombre, descripcion=descripcion, \
                observacion=observacion, complejidad=complejidad, \
                costo=costo, atributos=atributos)
            else:
                session.pop('id_item', None)
                session.pop('id_tipo_item', None)
                flash("La operacion se realizo con exito")
                return redirect(url_for('desarrollo_item'))

    item = obtener_datos_item(id_item_numerico)
    nombre = item['nombre']
    descripcion = item['descripcion']
    observacion = item['observacion']
    complejidad = item['complejidad']
    costo = item['costo']

    for atributo in atributos:
        pk = atributo['id']
        valor = obtener_valor_atributo(id_item_numerico, int(pk))
        item = dict(pk=pk, valor=str(valor))
        lista_atributos.append(item)

    atributos = cargar_valores_atributos(atributos, \
            lista_atributos)

    return render_template('modificar_item.html', id_usuario=id_usuario, \
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
    error=error, tipo_item=tipo_item, nombre=nombre, \
    descripcion=descripcion, observacion=observacion, \
    complejidad=complejidad, costo=costo, atributos=\
    atributos)

@app.route('/ver_relaciones', methods=['GET', 'POST'])
@login_required
def ver_relaciones():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    id_item = session["id_item"]
    id_item_numerico = int(id_item)
    lista_relaciones = listar_relaciones(id_item_numerico)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop("id_item", None)
            return redirect(url_for('desarrollo_item'))
        if request.form["action"] == "Agregar Antecesor":
            error = verificar_boton_agregar_relacion(id_item_numerico)
            if error == None:
                session['operacion'] = 'Antecesor'
                return redirect(url_for('crear_relacion'))
        if request.form["action"] == "Agregar Padre":
            error = verificar_boton_agregar_relacion(id_item_numerico)
            if error == None:
                session['operacion'] = 'Padre'
                return redirect(url_for('crear_relacion'))
        if request.form["action"] == "Eliminar":
            seleccionados = request.form.getlist("seleccionados")
            result = validar_eliminacion_relacion(seleccionados)
            if result != "OK":
                error = result
                return render_template('ver_relaciones.html', id_usuario=id_usuario, \
                nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
                error=error, items=lista_relaciones)
            
            id_relacion = int(seleccionados[0])
            result = eliminacion_relacion(id_relacion, id_item_numerico)
            if result != "OK":
                error = result
                return render_template('ver_relaciones.html', id_usuario=id_usuario, \
                nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
                error=error, items=lista_relaciones)
            
            lista_relaciones = listar_relaciones(id_item_numerico)
            flash("La operacion se realizo con exito")

    return render_template('ver_relaciones.html', id_usuario=id_usuario, \
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
    error=error, items=lista_relaciones)

@app.route('/crear_relacion', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Relacion')
def crear_relacion():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    operacion = session["operacion"]
    id_item = session["id_item"]
    lista_antecesores = listar_items_antecesores(nombre_proyecto, \
    nombre_fase)
    lista_padres = listar_items_padres(nombre_proyecto, nombre_fase)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop("operacion", None)
            return redirect(url_for('ver_relaciones'))

        if operacion == 'Antecesor':
            origen = request.form['select_antecesores']
        else:
            origen = request.form['select_padres']

        destino = id_item

        item_origen = int(origen)
        item_destino = int(destino)

        error = validar_datos_crear_relacion(item_origen, \
        item_destino)
        if error != None:
            return render_template('crear_relacion.html', id_usuario=\
            id_usuario, nombre_proyecto=nombre_proyecto, nombre_fase=\
            nombre_fase, error=error, lista_antecesores=\
            lista_antecesores, lista_padres=lista_padres, \
            origen_actual=item_origen, operacion=operacion)

        error = insertar_relacion(id_usuario, item_origen, \
        item_destino)
        if error != 'OK':
            return render_template('crear_relacion.html', id_usuario=\
            id_usuario, nombre_proyecto=nombre_proyecto, nombre_fase=\
            nombre_fase, error=error, lista_antecesores=\
            lista_antecesores, lista_padres=lista_padres, \
            origen_actual=item_origen, operacion=operacion)

        error = None
        item_destino = obtener_id_activo(item_destino)
        session["id_item"] = str(item_destino)
        flash("La operacion se realizo con exito")
        if request.form["action"] == "Guardar":
            return redirect(url_for('ver_relaciones'))
        else:
            lista_antecesores = listar_items_antecesores(\
            nombre_proyecto, nombre_fase)
            lista_padres = listar_items_padres(nombre_proyecto, \
            nombre_fase)

    return render_template('crear_relacion.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, nombre_fase=\
    nombre_fase, error=error, lista_antecesores=lista_antecesores, \
    lista_padres=lista_padres, operacion=operacion)

@app.route('/revivir_item', methods=['GET', 'POST'])
@login_required
@roles_accepted('Revivir Item')
def revivir_item():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    items = listar_items_eliminados(nombre_proyecto, nombre_fase)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('desarrollo_item'))
        if request.form["action"] == "Revivir":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_revivir_item(seleccionados)
            if error == None: #Si paso las validaciones
                error = revivir_items(nombre_proyecto, nombre_fase, \
                id_usuario, seleccionados)
                if error == 'OK':
                    flash('La operacion se realizo con exito')
                    return redirect(url_for('desarrollo_item'))

    return render_template('revivir_items.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, nombre_fase=\
    nombre_fase, error=error, items=items)

@app.route('/desarrollo_linea_base', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Linea Base', 'Romper Linea Base')
def desarrollo_linea_base():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    cadena = ""
    campo = "todos"
    items = []
    items = listar_linea_base(nombre_fase, nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_lineabase(cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Crear":
            return redirect(url_for('crear_lineabase'))
        if request.form["action"] == "Ver":
            seleccionados = request.form.getlist("seleccionados")
            error = verificar_parametros_ver_linea_base(seleccionados)
            if error == None:
                session["id_lineabase"] = seleccionados[0]
                return redirect(url_for('ver_linea_base'))
        if request.form["action"] == "Romper":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_boton_romper_lineabase(seleccionados)
            if error == None:
                session["id_lineabase"] = seleccionados[0]
                return redirect(url_for('romper_lineabase'))
        if request.form["action"] == "Salir":
            session.pop('nombre_fase', None)
            return redirect(url_for('desarrollo_fases'))

    return render_template('desarrollo_linea_base.html', items=items, \
    id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, 
    error=error)
    
@app.route('/importar_tipositem', methods=['GET', 'POST'])
@login_required
@roles_accepted('Importar Tipo Item')
def importar_tipositem():
    """Despliega una lista con las tipos de item de las fases de los distintos 
    proyectos de los cuales es lider. Selecciona una o varias para importarlas 
    a la fase actual"""
    items = []
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    nombre_fase = session['nombre_fase']
    cadena = ""
    campo = "todos"
    items = listar_tipositem_a_importar(id_usuario)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('desarrollo_tipoitem'))
            
        if request.form["action"] == "Buscar":
            cadena = request.form["cadena"]
            campo = request.form["campos"]
            items = buscar_tipos_item_importar(id_usuario, cadena, campo)
            if len(items) == 0:
                flash("No se encontraron coincidencias")
        if request.form["action"] == "Importar":
            seleccionados = request.form.getlist("seleccionados")
            result = validaciones_importar_tipoitem(seleccionados)
            if result != 'OK':
                error = result
                return render_template('importar_tipositem.html', id_usuario=\
                id_usuario, items=items, nombre_proyecto= nombre_proyecto,\
                nombre_fase=nombre_fase, error=error)
            result = importacion_tipositem(id_usuario, nombre_proyecto,\
            nombre_fase, seleccionados)
            if result != 'OK':
                error = result
                return render_template('importar_tipositem.html', id_usuario=\
                id_usuario, items=items, nombre_proyecto= nombre_proyecto,\
                nombre_fase=nombre_fase, error=error)
            flash("La operacion se realizo con exito")
            return redirect(url_for('desarrollo_tipoitem'))

    return render_template('importar_tipositem.html', id_usuario=id_usuario,\
    items=items, nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, error=error)
    

@app.route('/eliminar_item', methods=['GET', 'POST'])
@login_required
@roles_accepted('Eliminar Item')
def eliminar_item():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    id_item = session["id_item"]
    id_item_numerico = int(id_item)
    id_tipo_item = session["id_tipo_item"]
    id_tipo_item_numerico = int(id_tipo_item)
    tipo_item = obtener_nombre_tipo_item(id_tipo_item_numerico)
    atributos = traer_atributos_tipoitem(id_tipo_item_numerico)
    lista_atributos = []
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop('id_item', None)
            session.pop('id_tipo_item', None)
            return redirect(url_for('desarrollo_item'))
        
        result = eliminacion_item(id_item_numerico)
        if result != "OK":
            error = result
            return render_template('eliminar_item.html', id_usuario=id_usuario, \
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
            error=error, tipo_item=tipo_item, nombre=nombre, \
            descripcion=descripcion, observacion=observacion, \
            complejidad=complejidad, costo=costo, atributos=atributos)
        
        flash("La operacion se realizo con exito")
        return redirect(url_for('desarrollo_item'))
            
    item = obtener_datos_item(id_item_numerico)
    nombre = item['nombre']
    descripcion = item['descripcion']
    observacion = item['observacion']
    complejidad = item['complejidad']
    costo = item['costo']

    for atributo in atributos:
        pk = atributo['id']
        valor = obtener_valor_atributo(id_item_numerico, int(pk))
        item = dict(pk=pk, valor=str(valor))
        lista_atributos.append(item)

    atributos = cargar_valores_atributos(atributos, \
            lista_atributos)

    return render_template('eliminar_item.html', id_usuario=id_usuario, \
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
    error=error, tipo_item=tipo_item, nombre=nombre, \
    descripcion=descripcion, observacion=observacion, \
    complejidad=complejidad, costo=costo, atributos=\
    atributos)
    

@app.route('/crear_lineabase', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Linea Base')
def crear_lineabase():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    nombre = ''
    items = []
    items = listar_items_crear_lineabase(nombre_fase, nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('desarrollo_linea_base'))

        nombre = request.form['nombre']
        seleccionados = request.form.getlist("seleccionados")
        error = validaciones_crear_lineabase(nombre, seleccionados)
        if error == None:
            error = insertar_lineabase(id_usuario, \
            nombre_proyecto, nombre_fase, nombre, seleccionados)
            if error == "OK":
                flash("La operacion se realizo con exito")

                if request.form["action"] == "Guardar":
                    return redirect(url_for('desarrollo_linea_base'))

                error = None
                nombre = None
                items = listar_items_crear_lineabase(nombre_fase, \
                nombre_proyecto)

    return render_template('crear_lineabase.html', items=items, \
    error=error, id_usuario=id_usuario, nombre_proyecto=\
    nombre_proyecto, nombre_fase=nombre_fase, nombre=nombre)

@app.route('/romper_lineabase', methods=['GET', 'POST'])
@login_required
@roles_accepted('Romper Linea Base')
def romper_lineabase():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    id_lineabase = session["id_lineabase"]
    id_lineabase_numerico = int(id_lineabase)
    items = listar_items_romper_lineabase(id_lineabase_numerico)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop("id_lineabase", None)
            return redirect(url_for('desarrollo_linea_base'))
        if request.form["action"] == "Romper":
            error = eliminar_lineabase(id_lineabase_numerico)
            if error == 'OK':
                error = None
                flash('La operacion se realizo con exito')
                session.pop("id_lineabase", None)
                return redirect(url_for('desarrollo_linea_base'))

    return render_template('romper_lineabase.html', items=items, \
    error=error, id_usuario=id_usuario, nombre_proyecto=\
    nombre_proyecto, nombre_fase=nombre_fase)

@app.route('/eliminar_relacion', methods=['GET', 'POST'])
@login_required
@roles_accepted('Eliminar Relacion')
def eliminar_relacion():
    """Despliega una lista de todas las relaciones del cual el item 
    seleccionado es duenho"""
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    id_item = session["id_item"]
    id_item_numerico = int(id_item)
    relaciones = obtener_relaciones_activas_item(id_item)
    lista_atributos = []
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop('id_item', None)
            return redirect(url_for('desarrollo_item'))
        
        seleccionados = request.form.getlist("seleccionados")
        result = validar_eliminacion_relacion(seleccionados)
        if result != "OK":
            error = result
            return render_template('eliminar_relacion.html', id_usuario=id_usuario,\
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
            error=error, relaciones=relaciones)
        
        id_relacion = int(seleccionados[0])
        result = eliminacion_relacion(id_relacion, id_item_numerico)
        if result != "OK":
            error = result
            return render_template('eliminar_relacion.html', id_usuario=id_usuario,\
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
            error=error, relaciones=relaciones)
        
        flash("La operacion se realizo con exito")
        return redirect(url_for('desarrollo_item'))

    return render_template('eliminar_relacion.html', id_usuario=id_usuario, \
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
    error=error, relaciones=relaciones)


@app.route('/revertir_item', methods=['GET', 'POST'])
@login_required
@roles_accepted('Revertir Item')
def revertir_item():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    item_actual = None
    id_item = session["id_item"]
    id_item_numerico = int(id_item)
    versiones = obtener_versiones_items(id_item_numerico)
    
    if request.method == 'POST':
        try:
            if request.form["action"] == "Prueba":
                pass
        except:
            id_item_actual = request.form['select_version']
            id_item_actual_numerico = int(id_item_actual)
            item = obtener_datos_item(id_item_actual_numerico)
            id_tipoitem_numerico = obtener_id_tipo_item(id_item_actual_numerico)
            nombre_tipoitem = obtener_nombre_tipo_item(id_tipoitem_numerico)
            atributos = traer_atributos_tipoitem(id_tipoitem_numerico)
            lista_atributos = []
            for atributo in atributos:
                pk = atributo['id']
                valor = obtener_valor_atributo(id_item_actual_numerico, atributo['id'])
                elemento = dict(pk=pk, valor=valor)
                lista_atributos.append(elemento)
            
            atributos = cargar_valores_atributos(atributos, lista_atributos)
            relaciones = obtener_relaciones_item(id_item_actual_numerico)
            return render_template('revertir_item.html', id_usuario=id_usuario, \
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
            error=error, version_actual=id_item_actual_numerico, versiones=\
            versiones, nombre=item['nombre'], descripcion=item['descripcion'],\
            observacion=item['observacion'], complejidad=item['complejidad'],\
            costo=item['costo'], tipoitem=nombre_tipoitem, atributos=atributos,\
            relaciones=relaciones)
        
        if request.form["action"] == "Salir":
            session.pop('id_item', None)
            return redirect(url_for('desarrollo_item'))

        #si se selecciono "Guardar"
        id_item_actual = request.form['select_version']
        id_item_actual_numerico = int(id_item_actual)
        item = obtener_datos_item(id_item_actual_numerico)
        id_tipoitem_numerico = obtener_id_tipo_item(id_item_actual_numerico)
        nombre_tipoitem = obtener_nombre_tipo_item(id_tipoitem_numerico)
        atributos = traer_atributos_tipoitem(id_tipoitem_numerico)
        lista_atributos = []
        for atributo in atributos:
            pk = atributo['id']
            valor = obtener_valor_atributo(id_item_actual_numerico, atributo['id'])
            elemento = dict(pk=pk, valor=valor)
            lista_atributos.append(elemento)
        
        atributos = cargar_valores_atributos(atributos, lista_atributos)
        relaciones = obtener_relaciones_item(id_item_actual_numerico)
 
        result = validar_revertir_item(id_item_actual_numerico, id_item_numerico)
        if result != "OK":
            error = result
            return render_template('revertir_item.html', id_usuario=id_usuario, \
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
            error=error, version_actual=id_item_actual_numerico, versiones=\
            versiones, nombre=item['nombre'], descripcion=item['descripcion'],\
            observacion=item['observacion'], complejidad=item['complejidad'],\
            costo=item['costo'], tipoitem=nombre_tipoitem, atributos=atributos,\
            relaciones=relaciones)
        
        result = revercion_item(id_item_actual_numerico, id_item_numerico)
        if result != "OK":
            error = result
            return render_template('revertir_item.html', id_usuario=id_usuario, \
            nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase, \
            error=error, version_actual=id_item_actual_numerico, versiones=\
            versiones, nombre=item['nombre'], descripcion=item['descripcion'],\
            observacion=item['observacion'], complejidad=item['complejidad'],\
            costo=item['costo'], tipoitem=nombre_tipoitem, atributos=atributos,\
            relaciones=relaciones)
        
        session.pop('id_item', None)   
        flash("La operacion se realizo con exito")
        return redirect(url_for('desarrollo_item'))

    id_item_actual_numerico = id_item_numerico
    item = obtener_datos_item(id_item_actual_numerico)
    id_tipoitem_numerico = obtener_id_tipo_item(id_item_actual_numerico)
    nombre_tipoitem = obtener_nombre_tipo_item(id_tipoitem_numerico)
    atributos = traer_atributos_tipoitem(id_tipoitem_numerico)
    lista_atributos = []
    for atributo in atributos:
        pk = atributo['id']
        valor = obtener_valor_atributo(id_item_actual_numerico, atributo['id'])
        elemento = dict(pk=pk, valor=valor)
        lista_atributos.append(elemento)
    
    atributos = cargar_valores_atributos(atributos, lista_atributos)
    relaciones = obtener_relaciones_item(id_item_numerico)
    return render_template('revertir_item.html', id_usuario=id_usuario,\
    nombre_proyecto=nombre_proyecto, nombre_fase=nombre_fase,\
    error=error, version_actual=id_item_actual_numerico, versiones=\
    versiones, nombre=item['nombre'], descripcion=item['descripcion'],\
    observacion=item['observacion'], complejidad=item['complejidad'],\
    costo=item['costo'], tipoitem=nombre_tipoitem, atributos=atributos,\
    relaciones=relaciones)
    
@app.route('/ver_linea_base', methods=['GET', 'POST'])
@login_required
@roles_accepted('Crear Linea Base', 'Modificar Linea Base')
def ver_linea_base():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    id_lineabase = session['id_lineabase']
    id_lineabase_num = int(id_lineabase)
    items = listar_item_linea_base(id_lineabase_num)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop("id_lineabase", None)
            return redirect(url_for('desarrollo_linea_base'))

    return render_template('ver_linea_base.html', items=items, \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    nombre_fase=nombre_fase, error=error)

@app.route('/solicitud_de_cambio', methods=['GET', 'POST'])
@login_required
def solicitud_de_cambio():
    error = None
    id_usuario = session["id_usuario"]
    nombre_proyecto = session["nombre_proyecto"]
    cadena = ""
    campo = "todos"
    items = []
    items = listar_solicitudes(nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Ver":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_boton_ver_solicitud(seleccionados)
            if error == None:
                session['id_solicitud'] = seleccionados[0]
                return redirect(url_for('ver_solicitud'))
        if request.form["action"] == "Crear":
            error = validaciones_boton_crear_solicitud(nombre_proyecto)
            if error == None:
                return redirect(url_for('crear_solicitud'))
        if request.form["action"] == "Modificar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_boton_modificar_solicitud(\
            seleccionados, id_usuario, nombre_proyecto)
            if error == None:
                session['id_solicitud'] = seleccionados[0]
                return redirect(url_for('modificar_solicitud'))
        if request.form["action"] == "Eliminar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_boton_eliminar_solicitud(\
            seleccionados, id_usuario, nombre_proyecto)
            if error == None:
                session['id_solicitud'] = seleccionados[0]
                return redirect(url_for('eliminar_solicitud'))
        if request.form["action"] == "Enviar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_boton_enviar_solicitud(seleccionados, \
            id_usuario, nombre_proyecto)
            if error == None:
                error = postear_solicitud(seleccionados, id_usuario)
                if error == 'OK':
                    error = None
                    items = listar_solicitudes(nombre_proyecto)
                    flash('La operacion se realizo con exito')
        if request.form["action"] == "Votar":
            seleccionados = request.form.getlist("seleccionados")
            error = validaciones_boton_votar_solicitud(seleccionados, \
            id_usuario, nombre_proyecto)
            if error == None:
                session['id_solicitud'] = seleccionados[0]
                return redirect(url_for('votar_solicitud'))
        if request.form["action"] == "Reporte":
            return redirect(url_for('reporte_solicitud'))
        if request.form["action"] == "Salir":
            session.pop('nombre_proyecto', None)
            return redirect(url_for('desarrollo_proyectos'))

    return render_template('desarrollo_solicitud.html', items=items, \
    id_usuario=id_usuario, cadena=cadena, set_etc=campo,\
    nombre_proyecto=nombre_proyecto, error=error)

@app.route('/eliminar_solicitud', methods=['GET', 'POST'])
@login_required
def eliminar_solicitud():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    id_solicitud = session['id_solicitud']
    id_solicitud_numerico = int(id_solicitud)
    items = obtener_items_solicitud(id_solicitud_numerico)
    valores = obtener_valores_solicitud(id_solicitud_numerico)

    elemento = valores[0]

    identificador = elemento['identificador']
    descripcion = elemento['descripcion']
    impacto = elemento['impacto']
    solicitante = elemento['solicitante']
    fecha = elemento['fecha']
    miembros = elemento['lista_miembros']

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop('id_solicitud', None)
            return redirect(url_for('solicitud_de_cambio'))
        if request.form["action"] == "Eliminar":
            error = remover_solicitud(id_solicitud_numerico)
            if error == 'OK':
                session.pop('id_solicitud', None)
                flash('La operacion se realizo con exito')
                return redirect(url_for('solicitud_de_cambio'))

    return render_template('eliminar_solicitud.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    identificador=identificador, descripcion=descripcion, impacto=\
    impacto, solicitante=solicitante, fecha=fecha, items=items, \
    miembros=miembros)

@app.route('/crear_solicitud', methods=['GET', 'POST'])
@login_required
def crear_solicitud():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    descripcion = ''
    items = obtener_items_proyecto_solicitud(id_usuario, nombre_proyecto)

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('solicitud_de_cambio'))

        descripcion = request.form['descripcion']
        seleccionados = request.form.getlist("seleccionados")
        error = verificar_crear_solicitud(descripcion, seleccionados)
        if error == None:
            error = insertar_solicitud(id_usuario, nombre_proyecto, \
            descripcion, seleccionados)
            if error == None:
                flash("La operacion se realizo con exito")
                return redirect(url_for('solicitud_de_cambio'))
            else:
                items = obtener_items_solicitud_marcados(\
                id_usuario, nombre_proyecto, seleccionados)
        else:
            items = obtener_items_solicitud_marcados(\
            id_usuario, nombre_proyecto, seleccionados)

    return render_template('crear_solicitud.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    descripcion=descripcion, items=items)

@app.route('/modificar_solicitud', methods=['GET', 'POST'])
@login_required
def modificar_solicitud():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    id_solicitud = session['id_solicitud']
    id_solicitud_numerico = int(id_solicitud)
    lista_solicitud = obtener_valores_solicitud(id_solicitud_numerico)
    solicitud = lista_solicitud[0]
    items = obtener_items_modificar_solicitud(id_solicitud_numerico, \
    id_usuario, nombre_proyecto)
    descripcion = solicitud['descripcion']
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop(id_solicitud, False)
            return redirect(url_for('solicitud_de_cambio'))

        descripcion = request.form['descripcion']
        seleccionados = request.form.getlist("seleccionados")

        error = verificar_modificar_solicitud(descripcion, seleccionados)
        if error == None:
            error = modificacion_solicitud(id_usuario, \
            id_solicitud_numerico, descripcion, seleccionados)
            if error == None:
                flash("La operacion se realizo con exito")
                session.pop(id_solicitud, False)
                return redirect(url_for('solicitud_de_cambio'))
            else:
                items = obtener_items_solicitud_marcados(\
                id_usuario, nombre_proyecto, seleccionados)
        else:
            items = obtener_items_solicitud_marcados(\
            id_usuario, nombre_proyecto, seleccionados)

    return render_template('modificar_solicitud.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    descripcion=descripcion, items=items)

@app.route('/ver_solicitud', methods=['GET', 'POST'])
@login_required
def ver_solicitud():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    id_solicitud = session['id_solicitud']
    id_solicitud_numerico = int(id_solicitud)

    lista_solicitud = obtener_valores_solicitud(id_solicitud_numerico)
    solicitud = lista_solicitud[0]
    identificador = solicitud['identificador']
    descripcion = solicitud['descripcion']
    impacto = solicitud['impacto']
    solicitante = solicitud['solicitante']
    fecha = solicitud['fecha']
    miembros = solicitud['lista_miembros']

    items = obtener_items_ver_solicitud(id_solicitud_numerico)

    items_afectados = obtener_items_afectados(id_solicitud_numerico, \
    nombre_proyecto)

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop(id_solicitud, False)
            return redirect(url_for('solicitud_de_cambio'))

    return render_template('ver_solicitud.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    items=items, identificador=identificador, descripcion=descripcion, \
    impacto=impacto, solicitante=solicitante, fecha=fecha, miembros=\
    miembros, items_afectados=items_afectados)

@app.route('/administrar_comite', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def administrar_comite():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    items = listar_miembros_comite(nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop(nombre_proyecto, False)
            return redirect(url_for('administrar_proyectos'))
        if request.form["action"] == "Asignar Miembro":
            return redirect(url_for('lista_candidatos_comite'))
        if request.form["action"] == "Desasignar Miembro":
            seleccionados = request.form.getlist("seleccionados")
            error = validar_seleccion_desasignar_comite(\
            nombre_proyecto, seleccionados)
            if error == None:
                error = desasignar_miembros_comite(nombre_proyecto, \
                seleccionados)
                if error == 'OK':
                    flash('La operacion se realizo con exito')
                    error = None
                    items = listar_miembros_comite(nombre_proyecto)

    return render_template('administrar_comite.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    items=items)

@app.route('/lista_candidatos_comite', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def lista_candidatos_comite():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    items = listar_candidatos(nombre_proyecto)
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            return redirect(url_for('administrar_comite'))
        if request.form["action"] == "Asignar":
            seleccionados = request.form.getlist("seleccionados")
            error = validar_seleccion_candidatos_comite(seleccionados)
            if error == None:
                error = asignar_miembros_comite(nombre_proyecto, \
                seleccionados)
                if error == 'OK':
                    flash('La operacion se realizo con exito')
                    return redirect(url_for('administrar_comite'))

    return render_template('lista_candidatos_comite.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    items=items)

@app.route('/votar_solicitud', methods=['GET', 'POST'])
@login_required
def votar_solicitud():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    id_solicitud = session['id_solicitud']
    id_solicitud_numerico = int(id_solicitud)

    lista_solicitud = obtener_valores_solicitud(id_solicitud_numerico)
    solicitud = lista_solicitud[0]
    identificador = solicitud['identificador']
    descripcion = solicitud['descripcion']
    impacto = solicitud['impacto']
    solicitante = solicitud['solicitante']
    fecha = solicitud['fecha']
    observacion = ''
    miembros = solicitud['lista_miembros']

    items = obtener_items_ver_solicitud(id_solicitud_numerico)

    items_afectados = obtener_items_afectados(id_solicitud_numerico, \
    nombre_proyecto)

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop(id_solicitud, False)
            return redirect(url_for('solicitud_de_cambio'))

        observacion = request.form['observacion']
        voto = request.form["action"]
        error = insertar_voto(id_solicitud_numerico, id_usuario, \
        voto, observacion)
        if error == "OK":
            error = conteo_votos(id_solicitud_numerico, nombre_proyecto)
            if error == "OK":
                flash("La operacion se realizo con exito")
                return redirect(url_for('solicitud_de_cambio'))

    return render_template('votar_solicitud.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, error=error, \
    items=items, identificador=identificador, descripcion=descripcion, \
    impacto=impacto, solicitante=solicitante, fecha=fecha, \
    observacion=observacion, miembros=miembros, items_afectados=\
    items_afectados)

@app.route('/subir_archivo', methods=['GET', 'POST'])
@login_required
@roles_accepted('Modificar Item')
def subir_archivo():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    nombre_fase = session["nombre_fase"]
    id_item = session['id_item']
    id_item_numerico = int(id_item)

    atributos = listar_atributos_archivo(id_item_numerico)
    atrib_actual = 0

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop(id_item, False)
            return redirect(url_for('desarrollo_item'))

        if request.form["action"] == "Guardar":
            archivo = request.files['file']
            atrib_actual = int(request.form['select_atributo'])
            if atrib_actual != 0:
                if archivo:
                    filename = secure_filename(archivo.filename)
                    error = guardar_archivo(id_item, atrib_actual, \
                    archivo, id_usuario)
                    if error == "OK":
                        error = None
                        atrib_actual = 0
                        respuesta = crear_respuesta(archivo, filename)
                        return respuesta
                else:
                    error = "Debe seleccionar un archivo"
            else:
                error = "Debe seleccionar un atributo"

    return render_template('subir_archivo.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, nombre_fase=\
    nombre_fase, atributos=atributos, atrib_actual=atrib_actual, \
    error=error)

@app.route('/descargar_archivo', methods=['GET', 'POST'])
@login_required
@roles_accepted('Modificar Item')
def descargar_archivo():
    error = None
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    nombre_fase = session["nombre_fase"]
    id_item = session['id_item']
    id_item_numerico = int(id_item)

    atributos = listar_atributos_archivo(id_item_numerico)
    atrib_actual = 0

    if request.method == 'POST':
        if request.form["action"] == "Salir":
            session.pop(id_item, False)
            return redirect(url_for('desarrollo_item'))

        if request.form["action"] == "Descargar":
            atrib_actual = int(request.form['select_atributo'])
            if atrib_actual != 0:
                archivo = obtener_archivo(id_item, atrib_actual)
                if archivo != None:
                    nombre_archivo = generar_nombre_archivo(\
                    id_item, atrib_actual)
                    respuesta = crear_respuesta_descarga(archivo, \
                    nombre_archivo)
                    return respuesta
                else:
                    error = "El atributo seleccionado no posee un \
                    archivo"
            else:
                error = "Debe seleccionar un atributo"

    return render_template('descargar_archivo.html', id_usuario=\
    id_usuario, nombre_proyecto=nombre_proyecto, nombre_fase=\
    nombre_fase, atributos=atributos, atrib_actual=atrib_actual, \
    error=error)
    
@app.route('/finalizacion_proyecto', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def finalizacion_proyecto():
    """Se finaliza el proyecto seleccionado"""
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    error = None
    
    proyecto = db_session.query(Proyecto).filter_by(nombre = \
    nombre_proyecto).one()
    print "entro1"
    if request.method == 'POST':
        if request.form["action"] == "Salir":
            #Se borra la entrada en la cookie
            session.pop('nombre_proyecto', None)
            return redirect(url_for('administrar_proyectos'))

        p_nombre = request.form['nombre']
        p_descripcion = request.form['descripcion']
        p_observacion = request.form['observacion']
        p_presupuesto = request.form['presupuesto']
        p_finalizacion = request.form['finalizacion']

        resultado = finalizar_proyecto(p_nombre, p_finalizacion)

        if resultado == 'OK':
            flash("La operacion se realizo con exito")
            #Se borra la entrada en la cookie
            session.pop('nombre_proyecto', None)
            return redirect(url_for('administrar_proyectos'))
        else:
            error = resultado
            return render_template('finalizar_proyecto.html', error=error, \
            id_usuario = id_usuario, estado_proyecto=proyecto.estado, 
            nombre=proyecto.nombre, descripcion=proyecto.descripcion, \
            presupuesto=proyecto.presupuesto,observacion=proyecto.observacion)

    return render_template('finalizar_proyecto.html', error=error, \
    id_usuario = id_usuario, estado_proyecto=proyecto.estado, 
    nombre=proyecto.nombre, descripcion=proyecto.descripcion, \
    presupuesto=proyecto.presupuesto,observacion=proyecto.observacion)
    
@app.route('/finalizacion_fase', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def finalizacion_fase():
    """Logica de validacion para la finalizacion de las fases"""
    id_usuario = session['id_usuario']
    nombre_proyecto = session["nombre_proyecto"]
    nombre_fase = session["nombre_fase"]
    error = None
    
    proyecto = db_session.query(Proyecto).filter_by(nombre = \
    nombre_proyecto).one()
    fase = db_session.query(Fase).filter_by(fk_proyecto=proyecto.id).\
    filter_by(nombre = nombre_fase).one()
    
    if request.method == "POST":
        if request.form["action"] == "Salir":
            session.pop('nombre_fase', None)
            return redirect(url_for('administrar_fases'))

        nombre = request.form['nombre']
        descripcion = request.form['descripcion']
        observacion = request.form['observacion']
        orden = request.form['orden']
        finalizacion = request.form['finalizacion']
        
        result = finalizar_fase(nombre_proyecto, nombre_fase, finalizacion)
        if result != "OK":
            error = result
            return render_template('finalizar_fase.html', \
            id_usuario=id_usuario,nombre_proyecto=nombre_proyecto, \
            error=error, estado_fase=estado, nombre=nombre, \
            descripcion=descripcion, observacion=observacion, \
            orden=orden)
            
        flash("La operacion se realizo con exito")
        session.pop('nombre_fase', None)
        return redirect(url_for('administrar_fases'))

    return render_template('finalizar_fase.html', id_usuario=id_usuario,\
    nombre_proyecto=nombre_proyecto, error=error, \
    estado_fase=fase.estado, nombre=fase.nombre, \
    descripcion=fase.descripcion, observacion=fase.observacion, \
    orden=fase.orden)

@app.route('/reporte_solicitud', methods=['GET', 'POST'])
@login_required
@roles_accepted('Lider')
def reporte_solicitud():
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    items = []

    items = items_reporte_solicitud(id_usuario, nombre_proyecto)
    fecha = fecha_actual_str()

    pdf = create_pdf(render_template('reporte_solicitud.html', \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    items=items, fecha=fecha))

    respuesta = crear_respuesta(pdf, 'Reporte-Solicitud.pdf')

    return respuesta

@app.route('/reporte_items_proyecto', methods=['GET', 'POST'])
@login_required
def reporte_items_proyecto():
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    items = []

    items = items_reporte_proyecto(id_usuario, nombre_proyecto)
    fases_del_proyecto = fases_proyecto(nombre_proyecto)
    fecha = fecha_actual_str()

    pdf = create_pdf(render_template('reporte_items_proyecto.html', \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    items=items, fases_del_proyecto=fases_del_proyecto, fecha=fecha))

    respuesta = crear_respuesta(pdf, 'Reporte-Items-Proyecto.pdf')

    return respuesta

@app.route('/reporte_historial_item', methods=['GET', 'POST'])
@login_required
def reporte_historial_item():
    id_usuario = session['id_usuario']
    nombre_proyecto = session['nombre_proyecto']
    nombre_fase = session['nombre_fase']
    id_item = session['id_item']
    historial_item = []
    historial_valores = []

    historial_item = reporte_historial_item_lista(id_item)
    historial_valores = reporte_historial_valores(id_item, historial_item)
    fecha = fecha_actual_str()

    pdf = create_pdf(render_template('reporte_historial_item.html', \
    id_usuario=id_usuario, nombre_proyecto=nombre_proyecto, \
    nombre_fase=nombre_fase, historial_item=historial_item, \
    historial_valores=historial_valores, fecha=fecha))

    respuesta = crear_respuesta(pdf, 'Reporte-Historial-Item.pdf')

    return respuesta
    
@app.route('/crear_grafo', methods=['GET', 'POST'])
@login_required
def crear_grafo():
    nombre_proyecto = session["nombre_proyecto"]
    proyecto = db_session.query(Proyecto).filter_by(nombre = nombre_proyecto).one()
    fases = db_session.query(Fase).filter_by(fk_proyecto = proyecto.id).all()
    
    G = nx.DiGraph(weighted=False)
    G.posicion = {}
    G.poslabels = {}
    G.labels = {}
    G.colores = {}
    G.posComp = {}
    G.complej = {}
    posx = 0
    fases.sort(key=lambda x: x.orden)
    contador = 0
    for fase in fases:
        y = 600
        #itemFase = Items.query.filter(Items.id_fase == fase.id_fase).all()
        for tipo_item in fase.tipos_item:
            itemFase = db_session.query(Item).filter_by(fk_tipo_item = tipo_item.id).all()
            itemFase.sort(key=lambda x: x.id)
            for item in itemFase:
                if item.estado != "INA" and item.estado != "ELI":
                    
                    G.add_node(item.id)
                    #contador = contador + 1
                    #G.add_node(contador)
                    y = y - 3
                    x = posx + 0.35
                    G.posicion[item.id] = (x, y)
                    G.colores[item.id] = 'coral'
                    G.poslabels[item.id] = (x, y + 0.8) 
                    G.labels[item.id] = item.nombre
                    G.posComp[item.id] = (x + 2.5, y)
                    G.complej[item.id] = 'Comp:' + str(item.complejidad)
                    """G.posicion[contador] = (x, y)
                    G.colores[contador] = 'coral'
                    G.poslabels[contador] = (x, y + 0.8) 
                    G.labels[contador] = item.nombre
                    G.posComp[contador] = (x + 2.5, y)
                    G.complej[contador] = 'Comp:' + str(item.complejidad)"""
        posx = posx + 10
        
        for tipo_item in fase.tipos_item:
            itemFase = db_session.query(Item).filter_by(fk_tipo_item = tipo_item.id).all()
            itemFase.sort(key=lambda x: x.id)
            for item in itemFase:
                if item.estado != "INA" and item.estado != "ELI":
                    relacionesDestino = Relacion.query.filter(Relacion.fk_item_destino == item.id)
                    for relacion in relacionesDestino:
                        if ( relacion.estado == "ACT" ):
                            itemPadre = Item.query.filter(Item.id == relacion.fk_item_origen).one()
                            G.add_edge(itemPadre.id, item.id)
                            
                    """itemAntecesor = Relacion.query.filter(Relacion.fk_item_destino == item.id)
                    for ia in itemAntecesor:
                        if (ia.tipo == 2 and ia.activo == True):
                            itemAntecesor = Items.query.filter(Items.id_item == ia.id_origen).one()
                            G.add_edge(itemAntecesor.id_item, item.id_item)"""        
        plt.clf()
        nx.draw(G, G.posicion, node_color=[G.colores[v] for v in G], node_size=600)
        nx.draw_networkx_labels(G, G.poslabels, G.labels, fontsize=8)
        nx.draw_networkx_labels(G, G.posComp, G.complej, fontsize=8)

        strIO = StringIO.StringIO()
        plt.savefig(strIO, format='pdf')
        strIO.seek(0)

        respuesta = crear_respuesta(strIO, 'Grafo')

    return respuesta

@app.route('/ConstruirGrafos', methods=['GET', 'POST'])
@login_required
def ConstruirGrafos():
    """
    Contruye todos los grafos de relaciones de un item y obtiene los valores del calculo de 
    impacto para cada sub arbol, 1: sub arbol izquierdo, 2:sub arbol derecho
    3: sub arbol completo
    @param item: entidad del item sobre el cuals e contruiran los grafos
    @return: retorna un diccionario de datos con los calculos de impacto
    """

    paramID = session["id_item"]
    aristasIzquierda = Aristas()
    aristasDerecha = Aristas()
    aristasTotales = Aristas()
    item=db_session.query(Item).filter_by(id=paramID).first()

    ConstruirGrafoIzquierdo(item, aristasIzquierda)
    ConstruirGrafoDerecho(item, aristasDerecha)
    var = CombinarYConstruir(item, aristasIzquierda, aristasDerecha, aristasTotales)

    calculoIzq = CalcularImpacto(aristasIzquierda.items)
    calculoDer = CalcularImpacto(aristasDerecha.items)
    calculoTotal = CalcularImpacto(aristasTotales.items)
    flash("La operacion se realizo con exito")
    return redirect(url_for('desarrollo_item'))

if __name__ == '__main__':
    app.debug = True
    app.run()
